API

This is the internal API reference for ibek

ibek

ibek.__version__: str

Version number as calculated by pypa/setuptools_scm

ibek.globals

A few global definitions

class ibek.globals.BaseSettings

A Base class for setting consistent Pydantic model configuration

ibek.support

Support Class to represent a deserialized <MODULE_NAME>.ibek.support.yaml file.

class ibek.support.Support(*, shared: Sequence[Any] = (), module: str, entity_models: Sequence[EntityModel])

Lists the EntityModels for a support module, this defines what Entities it supports

ibek.ioc

Classes for generating an IocInstance derived class from a set of support module YAML files

ibek.ioc.clear_entity_model_ids()

Resets the global id_to_entity dict

class ibek.ioc.EnumVal(value)

An enum that is printed as its name only

class ibek.ioc.Entity(*, type: str, entity_enabled: bool = True)

A baseclass for all generated Entity classes.

add_ibek_attributes()

Whole Entity model validation

Do jinja rendering of pre_defines/ parameters / post_defines in the correct order.

Also adds pre_defines and post_defines to the model instance, making them available for the phase 2 (final) jinja rendering performed in ibek.runtime_cmds.generate().

model_post_init(context: Any, /) → None

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that’s what pydantic-core passes when calling it.

Parameters:

• self – The BaseModel instance.

• context – The context.

class ibek.ioc.IOC(*, ioc_name: str, description: str, entities: List[Entity], shared: Sequence[Any] = ())

Used to load an IOC instance entities yaml file into a Pydantic Model.

ibek.render

Functions for rendering lines in the boot script using Jinja2

class ibek.render.Render

A class for generating snippets of startup script / EPICS DB by using Jinja to combine snippet templates from support module yaml with substitution values supplied in ioc entity yaml

render_text(instance: Entity, text: str, when=When.every, suffix='') → str

Add in the next line of text, honouring the once flag which will only add the line once per IOC.

Jinja rendering of values/args has already been done in Entity.__post_init__ but we pass all strings though jinja again to render any other jinja in the IOC (e.g. database and function entries)

once uses the name of the model + suffix to track which lines have been rendered already. The suffix can be used where a given Entity has more than one element to render once (e.g. functions)

render_pre_ioc_init(instance: Entity) → str | None

render the startup script by combining the jinja template from an entity with the arguments from an Entity

render_post_ioc_init(instance: Entity) → str | None

render the post-iocInit entries by combining the jinja template from an entity with the arguments from an Entity

render_environment_variables(instance: Entity) → str | None

render the environment variable elements by combining the jinja template from an entity with the arguments from an Entity

render_elements(entities: Sequence[Entity], render_element: Callable[[Entity], str | None]) → str

Render elements of a given IOC instance based on calling the correct method

render_pre_ioc_init_elements(entities: Sequence[Entity]) → str

Render all of the startup script entries for a given IOC instance

render_post_ioc_init_elements(entities: Sequence[Entity]) → str

Render all of the post-iocInit elements for a given IOC instance

render_environment_variable_elements(entities: Sequence[Entity]) → str

Render all of the environment variable entries for a given IOC instance

ibek.utils

A class containing utility functions for passing into the Jinja context.

This allows us to provide simple functions that can be called inside Jinja templates with {{ _global.function_name() }}. It also allows us to maintain state between calls to the Jinja templates because we pass a single instance of this class into all Jinja contexts.

class ibek.utils.Utils

A Utility class for adding functions to the Jinja context

set_file_name(file: Path)

Set the ioc name based on the file name of the instance definition

set_ioc_name(name: str)

Set the ioc name based on the file name of the instance definition

get_env(key: str) → str

Get an environment variable

set(key: str, value: Any) → Any

create a global variable for our jinja context

get(key: str, default='') → Any

get the value a global variable for our jinja context

incrementor(name: str, start: int = 0, increment: int = 1, stop: int | None = None) → int

get a named counter that increments by inc each time it is called

creates a new counter if it does not yet exist

render(context: Any, template_text: Any) → str

Render a Jinja template with the global _global object in the context

render_map(context: Any, map: Mapping[str, str | None]) → dict[str, str]

Render a map of jinja templates with values from the given context.

If given a key with a value of None, the key itself will be used as a template value, so {"P": None} is equivalent to {"P": "{{ P }}"}.

Parameters:

• context – Context to extract template variables from

• map – Map of macro to jinja template to render

class apischema.types.UndefinedType

A sentinel value that allows detection that a value has not been passed at init