Core

This section contains source code documentation of hydratk.core modules.

bootstrapper

HydraTK core bootstrapper

hydratk.core.bootstrapper._check_dependencies(dep_modules={'importlib': {'package': 'importlib'}, 'setproctitle': {'min-version': '1.1.9', 'package': 'setproctitle'}, 'yaml': {'min-version': '3.11', 'package': 'pyyaml'}, 'psutil': {'min-version': '3.1.1', 'package': 'psutil'}, 'zmq': {'min-version': '14.7.0', 'package': 'pyzmq'}, 'xtermcolor': {'min-version': '1.3', 'package': 'xtermcolor'}}, source='hydratk')

Method checks if all dependent modules can be loaded

Parameters:
  • dep_modules (dict) – dependent modules
  • source (str) – source hydratk module
Returns:

result, False if any module is missing

Return type:

bool

hydratk.core.bootstrapper.check_home_param()

Method checks for home parameter presence –home or -h to replace htk_root_dir location

Parameters:none
Returns:htk_root_changed
Return type:bool
hydratk.core.bootstrapper.run_app()

Method runs HydraTK application

Method is executed from htk command (automatically installed)

Parameters:none
Returns:void
hydratk.core.bootstrapper.run_app_prof()

Method runs HydraTK application in profiling mode

Method is executed from htkprof command (automatically installed) C profiler lsprof is used

Parameters:none
Returns:void

corehead

HydraTK core module

class hydratk.core.corehead.AsyncCallBackHandler(hc)

Class AsyncCallBackHandler

__weakref__

list of weak references to the object (if defined)

class hydratk.core.corehead.CoreHead

Class CoreHead

Inherited from MessageHead, EventHandler, Debugger, Profiler, Logger

_bootstrap()

Method executes specific processing according to runlevel

Callback for functionality h_bootstrap

Parameters:none
Returns:True
Return type:bool
_create_config_db()

Method creates configuration database

Callback for command create-config-db Database filename is taken from option –config-db-file (prio 1), configuration System/DBConfig/db_file (prio 2)

If database exists it can be recreated using option -f|–force, otherwise is kept

Parameters:none
Returns:result
Return type:bool
_c_observer()

Method creates observer process and watches it during its lifecycle

When it is not active, application is stopped

Configuration options: Core/MessageService/id Core/MessageService/transport_type Core/MessageService/address Core/Service/pid_file

Parameters:

none

Returns:

void

Raises:
  • event – htk_before_cw_activity_check
  • event – htk_on_cobserver_ctx_switch
_c_worker(i, status, action_status, pipe_conn, is_alive_check)

Method watches worker process during its lifecycle

Process polls messages from queue

Parameters:
  • i (int) – process id
  • status (int) – activity status
  • action_status (int) – action status
  • pipe_conn (obj) – pipe process connection
  • is_alive_check (float) – time interval check
Returns:

void

Raises:

event – htk_on_cworker_init

_check_co_privmsg()

Method checks queue for observer messages and processes them

Parameters:none
Returns:void
_write_config_db(db_file)

Method writes data from configuration file to database

Parameters:db_file (str) – database filename including path
Returns:void
_dopoll(poller)

Method reads message from queue

Parameters:poller (obj) – message queue receiver
Returns:message
Return type:obj
_check_core_msg_queue()

Method checks queue for message

Message is sent via event if present (method doesn’t wait if queue is empty)

Parameters:none
Returns:True/False if queue is/isn’t empty
Return type:bool
_check_cw_privmsg()

Method checks queue for worker messages and processes them

Parameters:none
Returns:void
_check_cw_activity()

Method checks worker activity

Parameters:none
Returns:void
_do_command_action()

Method processes command

Command must have registered callback

Parameters:none
Returns:void
_load_db_config()

Method loads configuration from database

Database file is stored in configuration System/DBConfig/db_file

Parameters:none
Returns:void
_process_extension_configs()

Method searches configuration directory for extension specific configuration files

Each file is reported via event htk_before_append_extension_config_file

Parameters:none
Returns:void
Raises:event – htk_before_append_extension_config_file
_append_extension_config_from_file(ext_config_file)

Method parses extension configuration file

Parameters:ext_config_file (str) – config filename including path
Returns:void
_merge_base_config(config)

Method merges configuration with in memory configuration

Parameters:config (dict) – configuration with dictionary structure
Returns:void
config_var_default_processor(match)

Method is processing config variable definition from macro processor

Parameters:match (obj) – regexp object
Returns:parsed variable content
Return type:mixed
Raises:KeyError – for unavailable config variable keys
_load_base_config()

Method loads base configuration from file

Parameters:none
Returns:void
_apply_config()

Method initializes several configurable options

Debug, language, message router, count of workers

Configuration options: System/Debug/enabled System/Debug/level System/Language/id Core/Options/run_mode Core/MessageRoute/id Core/Workers/total

Parameters:none
Returns:void
_load_extensions()

Method loads extensions specified in configuration

Internal extensions are imported as module

External extensions are included to PYTHONPATH

Parameters:none
Returns:void
_load_extension(ext_name, ext_cfg)

Method loads internal extension

Parameters:
  • ext_name (str) – extension name
  • ext_cfg (dict) – extension configuration
Returns:

void

Raises:

exception – Exception

_extension_module_import(ext_full_path)

Method imports extension

Parameters:ext_full_path (str) – full module package name
Returns:module
Return type:obj
_load_module_from_file(filepath)

Method loads module from file

Supported formats: py (source code), pyc (compiled code)

Parameters:filepath (str) – filename including path
Returns:module
Return type:obj
_import_extension_messages(ext_path)

Method imports extension langtexts and commands help

Parameters:ext_path (str) – filename including path
Returns:void
_import_package_messages(import_package, msg_package)

Method imports package langtexts

Parameters:
  • import_package (str) – full package name
  • msg_package (str) – full package directory name
Returns:

void

_import_global_messages()

Method imports global langtexts and command help

Parameters:none
Returns:void
_reg_self_command_hooks()

Method registers global commands hooks

Parameters:none
Returns:void
_runlevel_baseinit()

Method executes specific processing for runlevel baseinit

Initialize translator, import global langtexts, register hooks

Parameters:none
Returns:True
Return type:bool
_runlevel_config()

Method executes specific processing for runlevel config

Load configuration from several sources - base, extensions, database

Parameters:none
Returns:True
Return type:bool
_runlevel_extensions()

Method executes specific processing for runlevel extensions

Load extensions

Parameters:

none

Returns:

True

Return type:

bool

Raises:
  • event – htk_before_load_extensions
  • event – htk_after_load_extensions
_runlevel_cli()

Method executes specific processing for runlevel cli

Parse command options

Parameters:none
Returns:True
Return type:bool
_runlevel_core()

Method executes specific processing for runlevel core

Subscribe managers if running in parallel processing mode

Parameters:none
Returns:True
Return type:bool
_runlevel_appl()

Method executes specific processing for runlevel appl

Process command

Parameters:none
Returns:True
Return type:bool
_run_command_option_hooks(command_opt, command_opt_value)

Method is processing specified command option callbacks.

This method runs automatically in runlevel cli, if there’re specified options.

Parameters:
  • command_opt (str) – command option
  • command_opt_value (str) – option value
Returns:

number of processed callbacks

Return type:

int

_run_command_hooks(command)

Method is processing specified command callbacks.

By default this method is called in runlevel appl if there’s command specified

Parameters:command (str) – command
Returns:number of processed callbacks
Return type:int
_set_default_cli_params()

Method initializes command line according to configuration

Parameters:none
Returns:void
_set_pid_file(pid_file)

Method creates PID file

Parameters:pid_file (str) – PID filename including path
Returns:PID
Return type:int
_notify_thread(pid)

Method notifies thread via signal SIGPIPE

Parameters:pid (int) – PID to be notified
Returns:void
_send_ping(thr)

Method sends PING message to thread

Parameters:thr (obj) – thread to be pinged
Returns:void
_service_starter(cb, service_status, parent_conn)

Method starts service process

Parameters:
  • cb (method) – callback method
  • service_status (int) – service status
  • parent_conn (obj) – pipe connection
Returns:

void

_sig_retriever(signum, frame)

Method handles received signal

If signal is supported (see hydratk.core.hsignal), new event is fired Not supported signals are ignored

Parameters:
  • signum (int) – signal number
  • frame – NOT USED
Returns:

void

Raises:
  • event – htk_on_signal
  • event – htk_on_sigterm|htk_on_sigint|htk_on_sigpipe|htk_on_sigalamr
_reg_service_signal_hooks()

Method registers signal hooks supported for services

Parameters:none
Returns:void
_reg_self_fn_hooks()

Method registers functionality hooks

Bootstrap, runlevels

Parameters:none
Returns:void
_reg_self_event_hooks()

Method registers event hooks

Parameters:none
Returns:void
_parse_cli_args()

Method parses command and options

Recognized commands are handled, unrecognized are ignored

Parameters:none
Returns:void
Raises:event – htk_on_cmd_options
_process_cw_msg(msg, thr)

Method processes PONG message from worker

Parameters:
  • msg (dict) – message
  • thr (obj) – thread
Returns:

void

_trigger_cmsg(msg)

Method sends message in event

Parameters:msg (dict) – message
Returns:void
Raises:event – htk_on_cmsg_recv
_response_ping(msg)

Method sends PONG message

Parameters:msg (dict) – message
Returns:void
_process_privmsg(msg)

Method processes private message

If PING message is received, PONG message is sent as response

Parameters:msg (dict) – message
Returns:void
Raises:event – h_privmsg_recv
_remove_pid_file(pid_file)

Method deletes PID file

Parameters:pid_file (str) – PID filename including path
Returns:result
Return type:bool
_reg_self_signal_hooks()

Method registers signal hooks

Parameters:none
Returns:void
_start_app()

Method starts application

Initialize observer process

Parameters:none
Returns:void
Raises:event – htk_on_start
_stop_app(force_exit=False)

Method stops application

Parameters:force_exit (bool) – force application stopping
Returns:void
Raises:event – htk_on_stop
_stop_app_command()

Method stops application in controlled way

Process is terminated using signal SIGTERM

Configuration options - Core/Service/pid_file

Parameters:none
Returns:void
_init_message_router()

Method initializes message router

Parameters:none
Returns:void
_list_extensions()

Method prints extension list

Parameters:none
Returns:void

dbconfig

HydraTK database configuration and settings module

class hydratk.core.dbconfig.DBConfig(db_file)

Class DBConfig

__init__(db_file)

Class constructor

called when the object is initialized
Parameters:db_file (str) – database file path
connect()

Method connects configuration database

Parameters:none
Returns:void
writedb(base_config)

Method writes configuration database using basic configuration

Parameters:base_config (dict) – configuration
Returns:result
Return type:bool
cfg2db(d)

Method converts base config data to the database input format

Parameters:d (dict) – base configuration
Returns:cfg
Return type:dict
db2cfg(active_only=False)

Method converts config database data to base config input format

Parameters:active_only (bool) – whether to load only active settings, default False
Returns:records
Return type:list

debugger

HydraTK core integrated debugger

class hydratk.core.debugger.Debugger

Class Debugger

fromhere(trace_level=1)

Method returns location of executed code

Dictionary {file, module, func, line, call_path}

Parameters:trace_level (int) – level in stacktrace
Returns:code location
Return type:dict
function()

Method returns executed function name

Parameters:none
Returns:function
Return type:str
file()

Method returns executed filename

Parameters:none
Returns:filename
Return type:str
line()

Method returns executed line number

Parameters:none
Returns:line number
Return type:int
module()

Method returns executed module name

Parameters:none
Returns:module
Return type:str
errmsg(*args)

Method prints error message

Parameters:args (list) – list of arguments
Returns:void
dmsg(event_id, *args)

Method sends debug message via event

Parameters:
  • event_id (str) – event
  • args (args) – arguments
Returns:

void

Raises:

event – event_id

match_channel(channel)

Method checks if required channels are tracked by debugger

Parameters:channel (obj) – required channel as int (channel id), list (channel ids)
Returns:result
Return type:bool
dout(msg, location={'line': '', 'call_path': '', 'func': '', 'module': '', 'file': ''}, level=1, channel=[])

Method prints debug message

Configuration options: System/Debug/msg_format System/Debug/term_color

Parameters:
  • msg (str) – message
  • location (dict) – location of executed code as dictionary {file, line, module, func, call_path} format returned by method fromhere
  • level (int) – required debug level, default 1
  • channel (obj) – required channel as int, channels as list of int, default all
Returns:

void

wout(msg, location={'line': '', 'call_path': '', 'func': '', 'module': '', 'file': ''})

Method prints warning message

Parameters:
  • msg (str) – message
  • location (dict) – location of executed code as dictionary {file, line, module, func, call_path} format returned by method fromhere
Returns:

void

errout(msg, location={'line': '', 'call_path': '', 'func': '', 'module': '', 'file': ''})

Method prints error message

Parameters:
  • msg (str) – message
  • location (dict) – location of executed code as dictionary {file, line, module, func, call_path} format returned by method fromhere
Returns:

void

exout(exc_type, exc_msg, exc_traceback)

Method prints exception including traceback

Parameters:
  • exc_type (str) – type of exception
  • exc_msg (str) – message
  • exc_traceback (obj) – traceback
Returns:

void

__weakref__

list of weak references to the object (if defined)

event

HydraTK default event class

class hydratk.core.event.Event(event_id, *args, **kwargs)

Class Event

__init__(event_id, *args, **kwargs)

Class constructor

Called when the object is initialized

Parameters:
  • event_id (str) – event
  • args (args) – arguments
  • kwargs (kwargs) – key value arguments
Raises:

error – ValueError

id()

Method gets id attribute

Parameters:none
Returns:str
argc()

Method gets count of arguments

Parameters:none
Returns:count of arguments
Return type:int
args()

Method gets args attribute

Parameters:none
Returns:tuple
get_all_data()

Method gets event data

Parameters:none
Returns:data
Return type:dict
get_data(key)

Method gets requested event data

Parameters:key (str) – data key
Returns:data value
Return type:obj
set_data(key, value)

Method sets requested event data

Parameters:
  • key (str) – data key
  • value (obj) – data value
Returns:

void

Raises:

error – ValueError

__weakref__

list of weak references to the object (if defined)

argv(num)

Method gets request event argument

Parameters:num (int) – argument index
Returns:argument value
Return type:obj
set_argv(num, val=None)

Method sets requested event argument

Parameters:
  • num (int) – argument index
  • val (obj) – argument value
Returns:

void

stop_propagation()

Method stops event propagation

Parameters:none
Returns:void
skip_before_hook

skip_before_hook property getter

skip_after_hook

skip_after_hook property getter

prevent_default()

Method prevents default event processing

Parameters:none
Returns:void
run_default()

Method enables default event processing

Parameters:none
Returns:void
will_run_default()

Method gets default event processing

Parameters:none
Returns:run_default
Return type:bool
propagate()

Method gets propagate attribute

Parameters:none
Returns:bool

eventhandler

HydraTK core event handling implementation class

class hydratk.core.eventhandler.EventHandler

Class EventHandler

extension

HydraTK extensions implementation class

class hydratk.core.extension.Extension(core_instance=None)

Class Extension

__getattr__(name)

Method gets required MasterHead attribute

Subclass must have enabled attribute _wrap_hydra_attrs

Parameters:name (str) – attribute name
Returns:attribute value
Return type:obj
Raises:error – AttributeError
__init__(core_instance=None)

Class constructor

Called when object is initialized Set extensions metadata If implemented in subclass - check dependencies, import modules, register actions

Parameters:core_instance (obj) – CoreHead reference
get_ext_name()

Method gets extension name

Parameters:none
Returns:name
Return type:str
get_ext_version()

Method gets extension version

Parameters:none
Returns:version
Return type:str
__weakref__

list of weak references to the object (if defined)

get_ext_author()

Method gets extension author

Parameters:none
Returns:author
Return type:str
get_ext_info()

Method gets extension summary info

Parameters:none
Returns:info
Return type:str

hookhead

HydraTK python system hooks

class hydratk.core.hookhead.ModuleLoader

Class ModuleLoader

find_module(module_name, package_path)

Method imports module langtexts

Parameters:
  • module_name (str) – full module name
  • package_path (str) – full package
Returns:

ModuleLoeader

Return type:

obj

load_module(module_name)

Method loads module

Parameters:module_name (str) – full module name
Returns:module
Return type:obj

logger

HydraTK core integrated logging features

class hydratk.core.logger.Logger

Class Logger

spout(data)

Method prints data

Parameters:data (str) – data

Returns:

__weakref__

list of weak references to the object (if defined)

masterhead

HydraTK master module

class hydratk.core.masterhead.MasterHead

Class MasterHead extends from CoreHead decorated by EventHandler, Debugger and Profiler

__init__()

Class constructor

MasterHead use singleton pattern, constructor should never be called directly

Parameters:none
Raises:error – ValueError
exception_handler(extype, value, traceback)

Exception handler hook

This method is registered as sys.excepthook callback and transforms unhandled exceptions to the HydraTK Event
Parameters:
  • extype (str) – Exception type
  • value (str) – Exception message info
  • (obj) Exception traceback object (traceback) –
Returns:

void

Raises:

event – htk_on_uncaught_exception

get_translator()

Method returns current traslator object initialized from hydratrk.lib.translation.translator.Translator

Parameters:none
Returns:Translator
Return type:obj
static get_head()

Method is primary connector to HydraTK core

This method returns current active MasterHead instance or creates a new one For preventing inner conflicts it’s designed as singleton
Parameters:none
Returns:MasterHead
Return type:obj

Example:

from hydratk.core.masterhead import MasterHead

mh = MasterHead.get_head()
get_config(var_filter=None, str_eval=True)

Method return current loaded configuration

Parameters:none
Returns:self._config
Return type:dict

Example:

from hydratk.core.masterhead import MasterHead

mh = MasterHead.get_head()
config = mh.get_config()
get_config_var(cfg_var, bind_vars=None, str_eval=True)

Method returns config varible

Parameters:
  • cfg_var (str) – config variable in format Group.Section.varname, eg.: System.Language.id
  • bind_vars (dict) – dictionary with bindable variables: $(var), which can be additionaly used while evaluating string value
  • str_eval (bool) – evaluate string value, default is True
Returns:

evaluated or raw string value

Return type:

str

Example:

from hydratk.core.masterhead import MasterHead

mh = MasterHead.get_head()
langue = mh.get_config_var('System.Language.id')
check_run_mode()

Method checks for run_mode input parameter (-m, –run-mode) from command line and validates if it’s supported

Parameters:none
Returns:run_mode_changed, True in case if it’s supported otherwise False
Return type:bool
check_language()

Method checks for language change input parameters (-l, –language) from command line and validates if it’s supported

Parameters:none
Returns:language_changed, True in case if it’s supported otherwise False
Return type:bool
check_config()
Method checks for config file change input parameters (-c, –config) from command line and validates its existence
If the new config file exists, then current config file path will be replaced by new one
Parameters:none
Returns:config_changed, True in case if config file exists otherwise False
Return type:bool
check_profile()

Method checks for profile option parameter (help, -p, –profile) with specified output statistics file

Parameters:none
Returns:result, bool enable_profiler, string statistics file
Return type:tuple
check_debug()

Method checks for debug option with specified level parameter (-d, –debug) from command line

Parameters:none
Returns:debug_changed, True in case if it’s set otherwise False
Return type:bool
check_debug_channel()

Method checks for debug channel option with specified channel filters from command line (-d, –debug-channel)

Parameters:none
Returns:debug_channel_changed, True in case if it’s set otherwise False
Return type:bool
match_short_option(opt, value_expected=False, d_opt=None, allow_multiple=False, opt_group='htk')

Method registers command line short option check

Parameters:
  • opt (str) – Short option string
  • value_expected (bool) – Whether the option value is expected or not
  • d_opt (str) – target option
  • allow_multiple (bool) – multiple option occurences allowed
  • opt_group (obj) – list or str, option group, default htk
Returns:

void

Raises:

error – TypeError

match_long_option(opt, value_expected=False, d_opt=None, allow_multiple=False, opt_group='htk')

Method registers command line long option check

Parameters:
  • opt (str) – long option string
  • value_expected (bool) – Whether the option value is expected or not
  • d_opt (str) – target option
  • allow_multiple (bool) – multiple option occurences allowed
  • opt_group (obj) – list or str, option group, default htk
Returns:

void

Raises:

error – TypeError

match_cli_option(opt, value_expected=False, d_opt=None, allow_multiple=False, opt_group='htk')

Method registers command option check

Parameters:
  • opt (obj) – tuple or list, short and long option strings
  • value_expected (bool) – Whether the option value is expected or not
  • d_opt (str) – target option
  • allow_multiple (bool) – multiple option occurences allowed
  • opt_group (obj) – list or str, option group, default htk
Raises:

error – TypeError

match_cli_command(cmd, opt_group='htk')

Method registers command line command check

Parameters:
  • cmd (str) – Command string
  • opt_group (str) – option group, default htk
Returns:

void

Raises:

error – ValueError: if the command is already registered for matching or the command is an empty string

set_cli_cmdopt_profile(profile)

Method sets new command option profile

Parameters:profile (str) – option group
Returns:void
Raises:error – InputError
set_cli_appl_title(help_title, cp_string)

Method sets custom application title

Parameters:
  • help_title (str) – help
  • cp_string (str) – copyright
Returns:

void

Raises:

error – InputError

register_fn_hook(fn_id, callback='')

Method adds/replaces functionality hook

Only one callback can be registered. This method is usable for functionality extending, replacement.
Parameters:
  • fn_id (mixed) – string functionality id or list of dictionaries in format {‘fn_id’ : ‘functionality_id’, ‘callback’ : callable_fc }
  • callback (callable) – User defined callback
Returns:

register success in case that fn_id is non-empty string int: number of successfully registered fn hooks in case that fn_id is list of dictionaries with multiple defined hooks

Return type:

bool

Example:

from hydratk.core.MasterHead import MasterHead

mh = MasterHead.get_head()
mh.register_fn_hook('mh_bootstrap', my_bootstrapper)
run_fn_hook(fn_id, *args, **kwargs)

Method is processing registered callback for specified fn_id.

This method is usable for functionality extending, replacement.
Parameters:
  • fn_id (str) – functionality id
  • args (mixed) – optional arguments
  • kwargs (mixed) – optional keyword arguments
Returns:

void

Raises:

exception – Exception

Example:

from hydratk.core.masterhead import MasterHead
from hydratk.core.event import Event

mh = MasterHead.get_head()
mh.run_fn_hook('mh_bootstrap')
dummy_fn_hook()

Method runs dummy hook

Parameters:none
Returns:True
Return type:bool
start_pp_app()

Method starts application in parallel mode

Parameters:none
Returns:void
stop_pp_app(force_exit=False)

Method stops application in parallel mode

Parameters:force_exit (bool) – force application termination
Returns:void
register_command_hook(cmd, callback='')

Method adds command hook

This method is usable for functionality extending, replacement, notification purposes etc.
Parameters:
  • cmd (mixed) – string Command or list of dictionaries in format {‘command’ : ‘defined_command’, ‘callback’ : callable_fc }
  • callback (callable) – User defined callback
Returns:

in case that cmd is defined by string int: number of successfully added hooks in case that cmd is dictionary with multiple defined callbacks

Return type:

bool

Example:

from hydratk.core.MasterHead import MasterHead

multi_hook = [
              {'command' : 'mycommand1', 'callback' : obj1.fc_command_handler1 }, # you can specify multiple command hooks
              {'command' : 'mycommand2', 'callback' : obj2.fc_command_handler2 },
              {'command' : 'mycommand3', 'callback' : fc_command_handler3 }
             ]

mh = MasterHead.get_head()
mh.register_command_hook(multi_hook) # register all hooks at once
mh.register_command_hook('mycommand4', fc_command_handler) # single registration
register_command_option_hook(cmd_opt, callback='')

Methods adds command option listener.

This method is usable for functionality extending, replacement, notification purposes etc.

Parameters:
  • cmd_opt (list or string) – Command option
  • callback (callable) – Function callback
Returns:

in case that cmd_opt is defined by string int: number of successfully added hooks in case that cmd_opt is dictionary with multiple defined callbacks

Return type:

bool

Example:

from hydratk.core.MasterHead import MasterHead

multi_hook = [
             {'command_option' : 'option', 'callback' : obj1.fc_command_handler1 }, # you can specify multiple option hooks
             {'command_option' : 'mycommand2', 'callback' : obj2.fc_command_handler2 },
             {'command_option' : 'mycommand3', 'callback' : fc_command_handler3 }
            ]

mh = MasterHead.get_head().
register_event_hook(event, callback='', unpack_args=False, priority=50)

Methods registers event listener.

This method is useful for extending the system functionality
Parameters:
  • event (list or string) – event
  • callback (callable) – function callback
  • unpack_args (bool) – optional request that arguments from event object will be passed directly to the listener, default false
  • priority (int) – optional priority number > 0, lower number means higher priority, default value is const.EVENT_HOOK_PRIORITY
Returns:

in case that cmd_opt is defined by string int: number of successfully registered hooks in case that event is dictionary with multiple defined callbacks

Return type:

bool

Example:

from hydratk.core.masterhead import MasterHead
from hydratk.core import const

mh = MasterHead.get_head()

hook = [
        {'event' : 'htk_on_error', 'callback' : self.my_error_handler, 'unpack_args' : True, 'priority' : const.EVENT_HOOK_PRIORITY - 1}, # will be prioritized
        {'event' : 'htk_on_warning', 'callback' : self.my_warning_handler, 'unpack_args' : False}
       ]

mh.register_event_hook(hook)
unregister_event_hook(event, callback=None)

Methods unregisters event listener(s) for specified event.

This method is useful for extending the system functionality
Parameters:
Returns:

in case that callback is not specified int: number of successfully unregistered hooks for matching callback

Return type:

bool

Example:

from hydratk.core.masterhead import MasterHead


mh = MasterHead.get_head()

hook = [
        {'event' : 'htk_on_error', 'callback' : self.my_error_handler, 'unpack_args' : True, 'priority' : const.EVENT_HOOK_PRIORITY - 1}, # will be prioritized
        {'event' : 'htk_on_warning', 'callback' : self.my_warning_handler, 'unpack_args' : False}
       ]

mh.register_event_hook(hook)
mh.unregister_event_hook('htk_on_error') # unregisters all hooks, returns True
mh.unregister_event_hook('htk_on_warning', self.my_warning_handler) # unregisers matching hook only, returns 1
replace_event_hook(event, callback, record)

Methods replaces event listener(s) for specified event.

This method is useful for extending the system functionality
Parameters:
  • event (string) – event
  • callback (callable) – matching callback
  • record (dict) – new callback record
Returns:

number of successfully replaced hooks for matching callback

Return type:

int

Raises:

exception – Exception

Example:

from hydratk.core.masterhead import MasterHead


mh = MasterHead.get_head()

hook = [
        {'event' : 'htk_on_error', 'callback' : self.my_error_handler, 'unpack_args' : True, 'priority' : const.EVENT_HOOK_PRIORITY - 1}, # will be prioritized
        {'event' : 'htk_on_warning', 'callback' : self.my_warning_handler, 'unpack_args' : False}
       ]

mh.register_event_hook(hook)

new_record = {
   'callback' : another_warning_handler,
   'unpack_args' : False
}

mh.replace_event_hook('htk_on_warning', self.my_warning_handler, new_record) # replaces matching hook only, returns 1
fire_event(oevent)

Method is processing specified event callbacks.

This method is usable for functionality extending, replacement, notification purposes etc.
Parameters:oevent (obj) – Event object type hydratk.core.event.Event
Returns:number of successfully processed event registered callbacks
Return type:int

Example:

from hydratk.core.masterhead import MasterHead
from hydratk.core.event import Event

mh = MasterHead.get_head()
event_id = 'myprefix_on_something_important'
oevent = Event('event_id')
oevent.set_data('alert','I just finished work')
print('This event was processed %d times' % mh.fire_event(oevent))
apply_command_options()

Method sets several command options

Debugging, language

Parameters:none
Returns:void
get_language()

Method gets language

Parameters:none
Returns:language
Return type:str
have_command_action()

Method checks if command is set

Parameters:none
Returns:result
Return type:bool
get_command_action()

Method gets command

Parameters:none
Returns:command
Return type:str
service_registered(service_name)

Method checks if service is registered

Parameters:service_name (str) – service
Returns:result
Return type:bool
register_service(service_name, description, cb)

Method registers given service and creates own process

Parameters:
  • service_name (str) – service
  • description (str) – description
  • cb (callable) – callback
Returns:

True

Return type:

bool

Raises:
  • error – TypeError
  • error – SystemError
  • error – ValueError
start_service(service_name)

Method starts service

Parameters:service_name (str) – service
Returns:result
Return type:bool
stop_services()

Method stops all running services

Service is tried via signal SIGINT first If not successful it is stopped via signal SIGKILL

Args:

Returns:void
init_core_threads()

Method initializes threads according to configuration

Parameters:none
Returns:void
destroy_core_threads()

Method destroys threads

Parameters:none
Returns:void
add_core_thread(i=None)

Method adds new thread to the pool

Parameters:i (int) – thread id
Returns:void
get_thrid()

Method gets thread id (name)

Parameters:none
Returns:id
Return type:str
create_ext_skel()

Method creates extension skeleton

Skeleton contains extension module, configuration, langtexts, installation In default (non-interactive) mode the skeleton is created from template in ~/hydratk directory In interactive mode the skeleton wizard asks the user for several data (path, name, author, ...)

Command line options - –force, –interactive, –ext-skel-path

Parameters:none
Returns:result
Return type:bool
create_lib_skel()

Method creates library skeleton

Skeleton contains extension module, installation In default (non-interactive) mode the skeleton is created from template in ~/hydratk directory In interactive mode the skeleton wizard asks the user for several data (path, name, author, ...)

Command line options - –force, –interactive, –lib-skel-path

Parameters:none
Returns:result
Return type:bool
async_fn_ex(fn_id, *args, **kwargs)

Method sends functionality hook in asynchronous way as message

Parameters:
  • fn_id (str) – functionality
  • args (args) – arguments
  • kwargs (kwargs) – key value arguments
Returns:

void

send_msg(msg)

Method send message to queue

Parameters:msg (obj) – message
Returns:void
async_ext_fn(callback, result_callback, *args, **kwargs)

Method sends extension hook in asynchronous way as message

Parameters:
  • callback (tuple) – callback
  • result_callback (obj) – str or tuple, callback
  • args (args) – arguments
  • kwargs (kwargs) – key value arguments
Returns:

ticket id

Return type:

str

Raises:
  • error – TypeError
  • error – KeyError
get_async_ticket_content(ticket_id)

Method gets ticket content

Parameters:

ticket_id (str) – ticket

Returns:

content

Return type:

obj

Raises:
  • error – KeyError
  • error – TypeError
async_ticket_completed(ticket_id)

Method checks if ticket processing is completed

Parameters:

ticket_id (str) – ticket

Returns:

result

Return type:

bool

Raises:
  • error – KeyError
  • error – TypeError
delete_async_ticket(ticket_id)

Method deletes ticket

Parameters:ticket_id (str) – ticket
Returns:void
register_async_fn_ex(fn_id, callback, result_callback=None)

Method registers functionality hook in asynchronous way

Parameters:
  • fn_id (str) – functionality hook
  • callback (callable) – callback
  • result_callback (callable) – result callback
Returns:

True

Return type:

bool

Raises:

error – TypeError

reg_fn_cb(fn_id, callback, options=None)

Method is registering callback with specified fn_id.

This method is usable for functionality extending, replacement.
Parameters:
  • fn_id (str) – functionality id
  • callback (callable) – callback
  • options – not used
Returns:

True

Return type:

bool

Raises:

error – TypeError

register_async_fn(fn_id, callback)

Method registers functionality hook in asynchronous way

Parameters:
  • fn_id (str) – functionality hook
  • callback (callable) – callback
Returns:

True

Return type:

bool

Raises:

error – TypeError

get_ext(extension_name)

Method gets extensions

Parameters:

extension_name (str) – extension

Returns:

Extension

Return type:

obj

Raises:
  • error – IndexError
  • error – TypeError

message

HydraTK core commmunication messages definition

class hydratk.core.message.Message

Class Message

__weakref__

list of weak references to the object (if defined)

class hydratk.core.message.FnCallBackMsg(callback, *args, **kwargs)

Class FnCallBackMsg

Inherited from Message

__init__(callback, *args, **kwargs)

Class constructor

Called when object is initialized

Parameters:
  • callback (callable) – callback
  • args (args) – arguments
  • kwargs (kwargs) – key value arguments
set_callback(callback)

Method sets callback

Parameters:callback (callable) – callback
Returns:void
Raises:error – TypeError
set_args(*args, **kwargs)

Method sets arguments

Parameters:
  • args (args) – arguments
  • kwargs (kwargs) – key value arguments
Returns:

void

run()

Method executes callback

Args:

Returns:callback output
Return type:obj

messagehead

HydraTK core commmunication messages processing fuctionality

class hydratk.core.messagehead.MessageHead

Class MessageHead

_new_async_ticket_id()

Method creates new ticket

Parameters:none
Returns:ticket id
Return type:str
_new_async_ticket(ticket_id)

Method creates dummy ticket

Parameters:ticket_id (str) – ticket
Returns:void
_delete_async_ticket(ticket_id)

Method deletes ticket

Parameters:

ticket_id (str) – ticket

Returns:

void

Raises:
  • error – KeyError
  • error – TypeError
_reset_async_ticket_seq()

Method resets ticket id sequence

Parameters:none
Returns:void
_reg_msg_handlers()

Method registers message handlers to functionality hooks

Parameters:none
Returns:void
_process_cmsg(ev, msg)

Method processes message

Message contains functionality hook to be executed

Parameters:
  • ev – not used
  • msg (obj) – message in Base64 format
Returns:

void

_send_msg(msg)

Method sends message

Parameters:msg (dict) – message
Returns:True
Return type:bool
_msg_async_ext_fn(msg)

Method runs funcionality hook callback from message

Parameters:msg (dict) – message
Returns:True
Return type:bool
__weakref__

list of weak references to the object (if defined)

messagerouter

HydraTK message router

class hydratk.core.messagerouter.MessageRouter(id)

Class MessageRoute

__init__(id)

Class constructor

Called when object is initialized

Parameters:id (str) – message router id
Returns:void
Raises:error – TypeError
register_service(id, transport_type, options)

Method will add router service identificator using specified parameters

Parameters:
  • id (str) – service identifier
  • transport_type (int) – supported transport type, currently only IPC and TCP is supported
  • options (dict) – transport_type supported options
Returns:

True

Return type:

bool

Raises:

error – InputError

get_queue(service_id, action, options={})

Method will return a new instance of queue object for specified service_id

Parameters:
  • service_id (str) – service identifier
  • options (dict) – queue type optional settings
Returns:

socket

Return type:

obj

get_service_address(service_id)

Method gets service address

Parameters:service_id (str) – service identifier
Returns:address
Return type:str

profiler

HydraTK core integrated profiler

class hydratk.core.profiler.Profiler

Class Profiler

__init__()

Class constructor

Called when object is initialized

Parameters:none
start()

Method starts profiler

Parameters:none
Returns:void
finish()

Method stops profiler

Parameters:none
Returns:void
_configure_profiler()

Method sets profiler command line configuration (options -p, –profile)

Parameters:none
Returns:void
__weakref__

list of weak references to the object (if defined)

propertyhead

HydraTK properties module

class hydratk.core.propertyhead.PropertyHead

Class PropertyHead

current_async_ticket_id

current_async_ticket_id property getter

async_fn_tickets

async_fn_tickets property getter, setter

fn_cb_shared

fn_cb_shared property getter, setter

cbm

cbm property getter

cli_cmdopt_profile

opt_profile property getter

cfg

config property getter

config_mp

Config macro processor instance

debug

debug property getter

debug_level

debug_level property getter

ext_cfg

extensions config property getter

__weakref__

list of weak references to the object (if defined)

lang

language property getter, setter

runlevel

runlevel property getter

run_mode

run_mode property getter, setter

servicehead

HydraTK core services

class hydratk.core.servicehead.ServiceHead

Class ServiceHead

srv_async_cb(cbo)

Method sends callback message

Parameters:cbo (obj) – callback object
Returns:void
__weakref__

list of weak references to the object (if defined)