"""Device layer of the Anton Paar touch-screen assets (front-panel group G07: Abbemat Advanced 5201, DMA 5002, MCR 503, Monowave 400, Ultrapyc 5000): what the instrument software keeps besides the measuring physics - settings, clock, users and logon, message list, favorites, methods and quick settings, sample list, data memory (measured / check / adjustment data, audit trail), user functions, and the front-panel host protocol of the generic panel engine (_panel_ui.py). Model: the M series instrument software (Abbemat 350/550 manual D22IB001PL-G, 'abm p.N'; Reference Guide General Software Functions XPAIB001EN-V, 'gsf p.N'). Each runtime passes a profile (quantities, method fields, factory methods, checks, hooks into its physics) and keeps its own physics; this module never touches the physics directly, only through the profile hooks. State lives in plain dicts on the host (host.ap, host.panel_state), so copies and comparisons of a runtime stay value-based (the runtimes' own tests compare copy.deepcopy(host.__dict__) with host.__dict__). Every command validates on a candidate copy and commits only when it succeeds: a refusal leaves the device unchanged.""" from __future__ import annotations import ast import copy import datetime import hashlib import math import re import tempfile from pathlib import Path from asset_runtime.mt_hx204 import ActionRejected EPOCH0 = datetime.datetime(2026, 1, 5, 8, 0, 0) # device clock at simulation time 0 (assumption; clock.set changes it) DEVICE_CODES = ['POWER_OFF', 'LOGON_REQUIRED', 'PERMISSION_DENIED', 'BUSY', 'WRONG_PASSWORD', 'ACCOUNT_LOCKED', 'IN_USE', 'NOT_FOUND', 'MEMORY_FULL', 'MANDATORY_FIELD', 'NOT_EXPORTED', 'NO_DEVICE', 'NO_PROCEDURE', 'CHECK_OVERDUE', 'NOT_ALLOWED'] def need(cond, code='PRECONDITION_FAILED'): if not cond: raise ActionRejected(code) # ---------------------------------------------------------------- argument schemas (subset shared with asset_tool.lint_schema) def num(unit, lo=None, hi=None, integer=False): s = {'type': 'integer' if integer else 'number', 'x-unit': unit} if lo is not None: s['minimum'] = lo if hi is not None: s['maximum'] = hi return s def obj(props, optional=(), extra=False): return {'type': 'object', 'properties': props, 'required': [k for k in props if k not in optional], 'additionalProperties': extra} def nullable(s): return {'anyOf': [s, {'type': 'null'}]} STR = {'type': 'string'} NAME = {'type': 'string', 'minLength': 1, 'maxLength': 50} BOOL = {'type': 'boolean'} ANYOBJ = {'type': 'object'} ACCEPTED = obj({'accepted': BOOL}) def check(schema, v, path='$'): """Validate a command argument against the schema subset used here (type incl. integer / null, enum, bounds, lengths, pattern, required, additionalProperties, items, anyOf); raises INVALID_ARGUMENT.""" if 'anyOf' in schema: for sub in schema['anyOf']: try: check(sub, v, path) return except ActionRejected: pass raise ActionRejected('INVALID_ARGUMENT') t = schema.get('type') ok = {'object': lambda x: isinstance(x, dict), 'string': lambda x: isinstance(x, str), 'boolean': lambda x: type(x) is bool, 'array': lambda x: isinstance(x, list), 'null': lambda x: x is None, 'integer': lambda x: isinstance(x, int) and not isinstance(x, bool), 'number': lambda x: isinstance(x, (int, float)) and not isinstance(x, bool) and math.isfinite(x)} need(t is None or ok[t](v), 'INVALID_ARGUMENT') if 'enum' in schema: need(any(v == e and type(v) is type(e) or (isinstance(v, (int, float)) and not isinstance(v, bool) and isinstance(e, (int, float)) and not isinstance(e, bool) and v == e) for e in schema['enum']), 'INVALID_ARGUMENT') if t in ('number', 'integer'): need(schema.get('minimum', -math.inf) <= v <= schema.get('maximum', math.inf), 'INVALID_ARGUMENT') if t == 'string': need(schema.get('minLength', 0) <= len(v) <= schema.get('maxLength', 10 ** 6), 'INVALID_ARGUMENT') if 'pattern' in schema: need(re.search(schema['pattern'], v) is not None, 'INVALID_ARGUMENT') if t == 'array': need(schema.get('minItems', 0) <= len(v) <= schema.get('maxItems', 10 ** 6), 'INVALID_ARGUMENT') for x in v: check(schema.get('items', {}), x, path) if t == 'object': need(set(schema.get('required', [])) <= set(v), 'INVALID_ARGUMENT') props = schema.get('properties', {}) for k, x in v.items(): sub = props.get(k, schema.get('additionalProperties', True)) need(sub is not False, 'INVALID_ARGUMENT') if isinstance(sub, dict): check(sub, x, f'{path}.{k}') # ---------------------------------------------------------------- settings tables def t_bool(key, label, default, ev, section, **kw): return dict(key=key, label=label, type='bool', default=default, ev=ev, section=section, **kw) def t_enum(key, label, options, default, ev, section, **kw): return dict(key=key, label=label, type='enum', options=list(options), default=default, ev=ev, section=section, **kw) def t_num(key, label, lo, hi, default, ev, section, unit=None, integer=False, **kw): return dict(key=key, label=label, type='int' if integer else 'num', min=lo, max=hi, default=default, ev=ev, section=section, unit=unit, **kw) def t_text(key, label, lo, hi, default, ev, section, **kw): return dict(key=key, label=label, type='text', min_len=lo, max_len=hi, default=default, ev=ev, section=section, **kw) def value_ok(f, v): t = f['type'] if t == 'bool': return type(v) is bool if t == 'enum': return any(v == o and type(v) is type(o) for o in f['options']) if t in ('int', 'num'): if isinstance(v, bool) or not isinstance(v, (int, float)) or not math.isfinite(v) or (t == 'int' and not float(v).is_integer()): return False return f['min'] - 1e-9 <= v <= f['max'] + 1e-9 if t == 'text': return isinstance(v, str) and f['min_len'] <= len(v) <= f['max_len'] and (not f.get('pattern') or re.search(f['pattern'], v) is not None) return False def field_schema(f): t = f['type'] if t == 'bool': return dict(BOOL) if t == 'enum': kinds = {type(o) for o in f['options']} s = {'enum': list(f['options'])} if kinds == {str}: s['type'] = 'string' return s if t in ('int', 'num'): return num(f.get('unit') or '1', f['min'], f['max'], integer=t == 'int') s = {'type': 'string', 'minLength': f['min_len'], 'maxLength': f['max_len']} if f.get('pattern'): s['pattern'] = f['pattern'] return s def settings_schema(fields, min_props=1): return {'type': 'object', 'properties': {f['key']: field_schema(f) for f in fields}, 'additionalProperties': False, 'minProperties': min_props} IP = dict(pattern=r'^(25[0-5]|2[0-4]\d|1?\d?\d)(\.(25[0-5]|2[0-4]\d|1?\d?\d)){3}$') LANGUAGES = ('English', 'Deutsch', 'Français', 'Español', 'Italiano') DATA_FORMATS = ('English (United States)', 'English (United Kingdom)', 'Deutsch (Deutschland)', 'Français (France)') KEYBOARDS = ('US', 'German', 'French') NAME_FIELDS = ('None', 'Date and Time', 'User Name', 'Sample Number', 'Method') # Instrument settings common to the M series software (ev = (Abbemat manual page, general-software-functions page)); 'right' is the user # right needed to change the section (abm p.47, Appendix F p.139-141: Setup is Administrator-only, Methods Manager / Administrator). MSERIES_SETTINGS = [ # Setup > Control Panel t_num('control.brightness', 'Display Brightness', 20, 100, 100, ('p.34', 'p.9'), 'brightness', unit='%', integer=True, assumption='factory brightness not given; 100 % assumed'), t_bool('control.screen_saver', 'Automatically switch off display after', True, ('p.34', 'p.9'), 'screen_saver', assumption='screen saver active by default (not stated)'), t_num('control.screen_saver_min', 'Minutes', 1, 300, 30, ('p.34', 'p.9'), 'screen_saver', unit='min', integer=True, visible=('control.screen_saver', True), assumption='factory time not given; 30 min assumed'), t_bool('control.beep_touch', 'Feedback beep on screen action', True, ('p.35', 'p.9'), 'beeps'), t_bool('control.beep_measurement', 'Beep when a measurement is finished', True, ('p.35', 'p.9'), 'beeps'), t_enum('region.language', 'Language', LANGUAGES, 'English', ('p.41', 'p.13'), 'regional', reboot=True), t_enum('region.data_format', 'Data Format', DATA_FORMATS, 'English (United States)', ('p.41', 'p.13'), 'regional', reboot=True), t_enum('region.keyboard', 'Keyboard Layout', KEYBOARDS, 'US', ('p.41', 'p.13'), 'regional', reboot=True), t_enum('units.temperature', 'Input unit for temperature', ('°C', '°F', 'K'), '°C', ('p.42', 'p.13'), 'input_units'), t_bool('network.dhcp', 'Obtain an IP address automatically (DHCP)', True, ('p.42', 'p.14'), 'network'), t_text('network.ip', 'IP Address', 7, 15, '192.168.0.100', ('p.42', 'p.14'), 'network', visible=('network.dhcp', False), **IP), t_text('network.subnet', 'Subnet Mask', 7, 15, '255.255.255.0', ('p.42', 'p.14'), 'network', visible=('network.dhcp', False), **IP), t_text('network.gateway', 'Default Gateway', 7, 15, '192.168.0.1', ('p.42', 'p.14'), 'network', visible=('network.dhcp', False), **IP), t_text('network.dns1', 'Primary DNS Server', 7, 15, '0.0.0.0', ('p.42', 'p.14'), 'network', page2=True, **IP), t_text('network.dns2', 'Secondary DNS Server', 7, 15, '0.0.0.0', ('p.42', 'p.14'), 'network', page2=True, **IP), t_text('instrument.name', 'Instrument name', 0, 30, '', ('p.42', 'p.15'), 'instrument_name'), t_text('instrument.location', 'Instrument location', 0, 30, '', ('p.42', 'p.15'), 'instrument_name'), t_bool('keyboard.barcode_sample_list', 'Use a bar code scanner to edit the sample list', False, ('p.37', 'p.11'), 'keyboard_barcode'), t_text('smtp.host', 'Host', 0, 64, '', ('p.51-52', 'p.20'), 'smtp'), t_num('smtp.port', 'Port', 1, 65535, 25, ('p.51-52', 'p.20'), 'smtp', integer=True, assumption='factory port not given; 25 assumed'), t_text('smtp.user', 'User name', 0, 64, '', ('p.51-52', 'p.20'), 'smtp'), t_text('smtp.password', 'Password', 0, 64, '', ('p.51-52', 'p.20'), 'smtp', secret=True), t_text('smtp.from', 'From address', 0, 64, '', ('p.51-52', 'p.20'), 'smtp'), t_bool('smtp.ssl', 'Enable SSL', False, ('p.51-52', 'p.20'), 'smtp'), t_enum('lims.baud', 'Baud rate', (1200, 2400, 4800, 9600, 19200, 38400, 57600, 115200), 9600, ('p.110', 'p.45'), 'rs232_lims'), t_enum('lims.data_bits', 'Data bits', (7, 8), 8, ('p.110', 'p.45'), 'rs232_lims'), t_enum('lims.parity', 'Parity', ('None', 'Even', 'Odd'), 'None', ('p.110', 'p.45'), 'rs232_lims'), t_enum('lims.stop_bits', 'Stop bits', (1, 2), 1, ('p.110', 'p.45'), 'rs232_lims'), t_enum('lims.handshake', 'Handshake', ('None', 'Hardware', 'Software'), 'None', ('p.110', 'p.45'), 'rs232_lims'), # Setup > Printout Settings t_bool('printout.auto', 'After each measurement', False, ('p.44', 'p.16'), 'auto_printout'), t_bool('printout.sub_samples', 'Enable printing of sub samples', False, ('p.44', 'p.16'), 'auto_printout'), t_text('printout.printer', 'Printer', 0, 50, 'PDF Export', ('p.44-45', 'p.16'), 'auto_printout'), t_text('printout.report', 'Report', 0, 50, 'Report 1', ('p.44-45', 'p.16'), 'auto_printout'), t_enum('printout.export_name', 'Export File Name', ('Time', 'Sample Name', 'Method'), 'Time', ('p.45', 'p.16'), 'auto_printout'), t_enum('printout.header_logo', 'Header logo', ('None', 'Anton Paar'), 'Anton Paar', ('p.44', 'p.16'), 'logos', assumption='internal logo list holds the factory logo only'), t_enum('printout.background_logo', 'Background logo', ('None', 'Anton Paar'), 'None', ('p.44', 'p.16'), 'logos'), t_text('printout.company', 'Name', 0, 40, '', ('p.44', 'p.16'), 'name_address'), t_text('printout.address', 'Address', 0, 80, '', ('p.44', 'p.16'), 'name_address'), # Setup > Measuring System Settings > Sample List / Sample Settings t_enum('samples.mode', 'Sample List Mode', ('No Sample List', 'Sample List'), 'No Sample List', ('p.46', 'p.16-17'), 'sample_naming'), t_text('samples.prefix', 'Sample Name Prefix', 0, 20, '', ('p.45-46', 'p.16-17'), 'sample_naming'), t_enum('samples.prefix_field', 'Prefix data field', NAME_FIELDS, 'None', ('p.45', 'p.16'), 'sample_naming'), t_text('samples.postfix', 'Sample Name Postfix', 0, 20, '', ('p.45-46', 'p.16-17'), 'sample_naming'), t_enum('samples.postfix_field', 'Postfix data field', NAME_FIELDS, 'None', ('p.45', 'p.16'), 'sample_naming'), t_bool('samples.field1', 'User-defined Data Field 1', False, ('p.46', 'p.17'), 'data_fields'), t_text('samples.field1_name', 'Name of data field 1', 1, 20, 'Data Field 1', ('p.46', 'p.17'), 'data_fields', visible=('samples.field1', True)), t_bool('samples.field2', 'User-defined Data Field 2', False, ('p.46', 'p.17'), 'data_fields'), t_text('samples.field2_name', 'Name of data field 2', 1, 20, 'Data Field 2', ('p.46', 'p.17'), 'data_fields', visible=('samples.field2', True)), t_bool('samples.field3', 'User-defined Data Field 3', False, ('p.46', 'p.17'), 'data_fields'), t_text('samples.field3_name', 'Name of data field 3', 1, 20, 'Data Field 3', ('p.46', 'p.17'), 'data_fields', visible=('samples.field3', True)), t_bool('samples.warn_no_name', 'Warn if sample list contains a sample without a name', False, ('p.46', 'p.17'), 'list_warnings'), t_bool('samples.warn_temperatures', 'Warn if sample list contains methods with different measuring temperatures', False, ('p.46', 'p.17'), 'list_warnings'), t_bool('samples.mandatory_name', 'Sample name is mandatory', False, ('p.46', 'p.17'), 'mandatory'), t_bool('samples.mandatory_field1', 'Data field 1 is mandatory', False, ('p.46', 'p.17'), 'mandatory'), t_bool('samples.mandatory_field2', 'Data field 2 is mandatory', False, ('p.46', 'p.17'), 'mandatory'), t_bool('samples.mandatory_field3', 'Data field 3 is mandatory', False, ('p.46', 'p.17'), 'mandatory'), # Data memory settings t_bool('memory.auto_delete', 'Automatically delete old measured data', False, ('p.87', 'p.25'), 'memory_settings'), t_bool('memory.auto_delete_checks', 'Automatically delete old check data', False, ('p.87', 'p.25'), 'check_memory_settings'), # Setup > System Security t_enum('security.level', 'Security Level', ('Low', '21 CFR Part 11', 'User-defined'), 'Low', ('p.52-53', 'p.29'), 'security_level'), t_bool('security.audit_trail', 'Audit Trail active', False, ('p.57', 'p.32'), 'audit_trail'), t_bool('security.audit_reminder', 'Audit Trail Backup Reminder', False, ('p.57', 'p.32'), 'audit_trail'), t_num('security.audit_reminder_days', 'Reminder interval', 1, 365, 7, ('p.53', 'p.29'), 'audit_trail', unit='days', integer=True, visible=('security.audit_reminder', True)), t_bool('security.esign', 'Electronic Signature', False, ('p.59', 'p.34'), 'esign'), t_bool('security.esign_password', 'Electronic Signature requires Password', False, ('p.59', 'p.34'), 'esign', visible=('security.esign', True)), t_enum('security.esign_levels', 'Electronic Signature Levels', ('3 roles', '2 roles'), '3 roles', ('p.58', 'p.34'), 'esign', visible=('security.esign', True)), t_bool('security.esign_substitute', 'Allow substitute signing', True, ('p.58', 'p.34'), 'esign', visible=('security.esign', True)), t_bool('security.auto_logoff', 'Auto logoff', False, ('p.54', 'p.30'), 'logon'), t_num('security.auto_logoff_min', 'Auto logoff time', 1, 60, 60, ('p.54', 'p.30'), 'logon', unit='min', integer=True, visible=('security.auto_logoff', True)), t_bool('security.pw_expiry', 'Password expires', False, ('p.54', 'p.30'), 'logon'), t_num('security.pw_expiry_days', 'Password expiry time', 1, 60, 60, ('p.54', 'p.30'), 'logon', unit='days', integer=True, visible=('security.pw_expiry', True)), t_bool('security.pw_min_active', 'Minimum password length', False, ('p.54', 'p.30'), 'logon'), t_num('security.pw_min_length', 'Password length', 6, 30, 6, ('p.54', 'p.30'), 'logon', integer=True, visible=('security.pw_min_active', True)), t_bool('security.increased', 'Increased Security', False, ('p.54-55', 'p.31'), 'increased_security'), t_bool('security.disable_usb', 'Disable USB memory devices', False, ('p.56', 'p.31'), 'advanced_security'), t_bool('security.service_password', 'Service logon requires customer password', False, ('p.56', 'p.31'), 'advanced_security'), ] SECTION_RIGHT = {'brightness': 'setup_control_panel', 'screen_saver': 'setup_control_panel', 'beeps': 'setup_control_panel', 'regional': 'setup_control_panel', 'input_units': 'setup_control_panel', 'network': 'setup_control_panel', 'instrument_name': 'setup_control_panel', 'keyboard_barcode': 'setup_control_panel', 'smtp': 'setup_control_panel', 'rs232_lims': 'setup_control_panel', 'auto_printout': 'setup_printout', 'logos': 'setup_printout', 'name_address': 'setup_printout', 'sample_naming': 'setup_measuring', 'data_fields': 'setup_measuring', 'list_warnings': 'setup_measuring', 'mandatory': 'setup_measuring', 'memory_settings': 'data_settings', 'check_memory_settings': 'data_settings', 'security_level': 'setup_security', 'audit_trail': 'setup_security', 'esign': 'setup_security', 'logon': 'setup_security', 'increased_security': 'setup_security', 'advanced_security': 'setup_security'} SECURITY_LEVELS = { # abm Table 9.1 p.53 (gsf Table 2 p.29) 'Low': {'security.audit_trail': False, 'security.esign': False, 'security.auto_logoff': False, 'security.pw_expiry': False, 'security.increased': False}, '21 CFR Part 11': {'security.audit_trail': True, 'security.audit_reminder': True, 'security.audit_reminder_days': 7, 'security.esign_password': True, 'security.auto_logoff': True, 'security.auto_logoff_min': 60, 'security.pw_expiry': True, 'security.pw_expiry_days': 60, 'security.increased': True}} # ---------------------------------------------------------------- users, groups and rights (abm p.47-50, gsf p.18-20) RIGHTS = ('measure', 'method_select', 'quick_settings', 'sample_list', 'checks', 'monitor', 'favorites', 'data_view', 'adjustments', 'output_fields', 'method_settings', 'method_management', 'data_delete', 'data_settings', 'check_settings', 'user_functions', 'setup_measuring', 'setup_control_panel', 'setup_printout', 'setup_security', 'setup_users', 'service') RIGHT_LABELS = {'measure': 'Start / Stop measurements', 'method_select': 'Select a method', 'quick_settings': 'Quick settings', 'sample_list': 'Edit the sample list', 'checks': 'Perform checks', 'monitor': 'Monitor mode', 'favorites': 'Favorites', 'data_view': 'View data memory', 'adjustments': 'Perform adjustments', 'output_fields': 'Change output fields', 'method_settings': 'Method settings', 'method_management': 'Method management / visibility', 'data_delete': 'Delete data', 'data_settings': 'Data memory settings', 'check_settings': 'Check / standard management', 'user_functions': 'User functions', 'setup_measuring': 'Measuring system settings', 'setup_control_panel': 'Control panel', 'setup_printout': 'Printout settings', 'setup_security': 'System security', 'setup_users': 'User management', 'service': 'Service'} OPERATOR_RIGHTS = ['measure', 'method_select', 'quick_settings', 'sample_list', 'checks', 'monitor', 'favorites', 'data_view'] MANAGER_RIGHTS = OPERATOR_RIGHTS + ['adjustments', 'output_fields', 'method_settings', 'data_delete', 'check_settings'] STANDARD_GROUPS = [dict(name='Administrator', base='Administrator', icon='Administrator', rights=list(RIGHTS), standard=True), dict(name='Manager', base='Manager', icon='Manager', rights=list(MANAGER_RIGHTS), standard=True), dict(name='Operator', base='Operator', icon='Operator', rights=list(OPERATOR_RIGHTS), standard=True)] GROUP_ICONS = ('Administrator', 'Manager', 'Operator', 'Icon 4', 'Icon 5', 'Icon 6', 'Icon 7') FACTORY_USERS = [dict(name='Administrator', group='Administrator', password='administrator', active=True, auto_logon=True, role='None', sign_name='', email='', email_active=False, failed=0, history=[]), dict(name='Manager', group='Manager', password='manager', active=True, auto_logon=False, role='None', sign_name='', email='', email_active=False, failed=0, history=[]), dict(name='Operator', group='Operator', password='operator', active=True, auto_logon=False, role='None', sign_name='', email='', email_active=False, failed=0, history=[])] SIGN_ROLES = ('None', 'Submitter', 'Reviewer', 'Approver') # ---------------------------------------------------------------- data memory filters (abm p.89-90, gsf p.26) FILTER_CRITERIA = ('Sample Name', 'Method', 'User', 'Date Range', 'Sample Error State', 'Print/Export Status', 'Measuring Value', 'Master Condition') COMPARATORS = ('equals', 'not equal', 'larger than', 'smaller than', 'containing', 'not containing', 'printed/exported', 'not printed/exported') DATE_RANGES = ('Today', 'Yesterday', 'Last Week', 'Last Month') MEASUREMENT_TYPES = {'S': 'S (Standard)', 'C': 'C (Check)', 'MM': 'MM (Multiple Measurement)', 'MF': 'MF (Multi Fill)', 'TS': 'TS (Temperature Scan)', 'RM': 'RM (Repeated Mode)', 'TTS': 'TTS (Temperature Table Scan)'} # RM / TTS: DMA M (dma p.36-38) RM_SAVE = ('all', 'valid two only', 'final one only') PRINTER_TYPES = ('RS-232 printer', 'PCL printer (USB)', 'PCL printer (network)', 'PDF File Printer') REPORT_TYPES = ('Detail Report', 'List Report') FUNCTION_TYPES = ('Constant', 'Formula', 'Linear Function', 'Polynomial (1D)', 'Polynomial (2D)', 'Table') # ---------------------------------------------------------------- device state def new_device(profile): """Factory state of the device layer (as delivered: Administrator logged on by auto logon, abm p.47; factory methods; no data).""" settings = {f['key']: copy.deepcopy(f['default']) for f in profile['settings']} methods = [method_record(profile, m) for m in profile['factory_methods']] ap = dict(settings=settings, clock_offset_s=0.0, users=copy.deepcopy(FACTORY_USERS), groups=copy.deepcopy(STANDARD_GROUPS), user=None, last_input_s=0.0, boot_s=0.0, power_epoch=0, messages=[], next_msg=1, favorites=copy.deepcopy(profile.get('fixed_favorites', [])), methods=methods, active=methods[0]['name'], quick=quick_from_method(profile, methods[0]), sample_no=1, sample_list=[], templates=[dict(name=f'Sample List {i + 1}', entries=[]) for i in range(10)], data=[], next_data=1, check_data=[], next_check=1, adjustments=[], next_adj=1, audit=[], next_audit=1, filters=dict(view=[], delete=[], check=[]), printers=[], shares=[], reports=[dict(name='Report 1', type='Detail Report', default=True, gxp=False, orientation='Portrait', printed_by=True)], browser=list(profile['browser_default']), functions=[], checks=copy.deepcopy(profile.get('factory_checks', [])), standards=copy.deepcopy(profile.get('factory_standards', [])), run=None, monitor=True, frozen=None, frozen_rec=None, procedure=None, extrapolation=copy.deepcopy(profile.get('extrapolation_default', [])), touch_cal=None, firmware_checked=None, reboot_pending=False, beeps=0, auto_printouts=0, unique=1) ap.update(copy.deepcopy(profile.get('device_extra', {}))) ap['user'] = auto_logon_user(ap) return ap def method_record(profile, m): out = dict(name=m['name'], visible=True, protected=m.get('protected', False), settings={f['key']: f['default'] for f in profile['method_fields']}, mode='S', mm_count=3, mf_count=2, ts_start=20.0, ts_step=5.0, ts_end=40.0, check=None, layout=profile['layouts'][0][0], rm_count=3, rm_dev=None, rm_save='all', tts_temps=[], **copy.deepcopy(profile.get('method_extra_defaults', {})), fields=copy.deepcopy(profile['default_fields']), output=copy.deepcopy(profile['default_output']), limits=[], quick=list(profile['quick_default']), modules={}, constants={}) for k, v in m.items(): if k in out['settings']: out['settings'][k] = v elif k in out and k != 'name': out[k] = copy.deepcopy(v) return out def quick_from_method(profile, m): q = dict(sample_name='', type=m['mode'], mm_count=m['mm_count'], mf_count=m['mf_count'], ts_start=m['ts_start'], ts_step=m['ts_step'], ts_end=m['ts_end'], check=m['check'], field1='', field2='', field3='', rm_count=m.get('rm_count', 3), rm_dev=m.get('rm_dev'), rm_save=m.get('rm_save', 'all'), tts_temps=list(m.get('tts_temps', []))) q.update({k: m['settings'][k] for k in profile['quick_fields'] if k in m['settings']}) return q def method(ap, name=None): name = ap['active'] if name is None else name for m in ap['methods']: if m['name'] == name: return m return None def auto_logon_user(ap): if ap['settings'].get('security.increased') or ap['settings'].get('security.audit_trail'): return None # abm p.48, p.57: auto logon disabled with increased security / audit trail for u in ap['users']: if u['auto_logon'] and u['active']: return u['name'] return None def user_record(ap, name): for u in ap['users']: if u['name'].lower() == str(name).lower(): return u return None def group_record(ap, name): for g in ap['groups']: if g['name'] == name: return g return None def rights_of(ap): u = user_record(ap, ap['user']) if ap['user'] else None g = group_record(ap, u['group']) if u else None return list(g['rights']) if g else [] def has_right(ap, right): return right in rights_of(ap) # ---------------------------------------------------------------- clock def device_dt(host): return EPOCH0 + datetime.timedelta(seconds=host.time_s + host.ap['clock_offset_s']) def device_iso(host): return device_dt(host).replace(microsecond=0).isoformat() def clock_text(host): dt = device_dt(host) if host.ap['settings'].get('region.data_format', '').startswith('English (United States)'): h = dt.hour % 12 or 12 return f'{h}:{dt.minute:02d}:{dt.second:02d} {"AM" if dt.hour < 12 else "PM"}' return f'{dt.hour:02d}:{dt.minute:02d}:{dt.second:02d}' def date_text(host, dt=None): dt = dt or device_dt(host) fmt = host.ap['settings'].get('region.data_format', '') if fmt == 'English (United States)': return f'{dt.month}/{dt.day}/{dt.year}' if fmt == 'English (United Kingdom)': return f'{dt.day:02d}/{dt.month:02d}/{dt.year}' return f'{dt.day:02d}.{dt.month:02d}.{dt.year}' # ---------------------------------------------------------------- messages and audit trail def add_message(host, level, text): ap = host.ap if any(m['text'] == text for m in ap['messages']): return ap['messages'].append(dict(id=ap['next_msg'], level=level, text=text, time=device_iso(host))) ap['next_msg'] += 1 def status(ap): levels = {m['level'] for m in ap['messages']} return 'error' if 'error' in levels else 'warning' if 'warning' in levels else 'ok' def audit(host, text): ap = host.ap if not ap['settings'].get('security.audit_trail'): return ap['audit'].append(dict(id=ap['next_audit'], time=device_iso(host), user=ap['user'] or '-', text=text, comment='', exported=False)) ap['next_audit'] += 1 if len(ap['audit']) > 999: # abm p.57: up to 999 entries del ap['audit'][:-999] # ---------------------------------------------------------------- formatting of values (unit conversion, digits) def to_unit(q, value, unit): if value is None: return None if q.get('kind') == 'temperature': return value if unit == '°C' else value * 9.0 / 5.0 + 32.0 if unit == '°F' else value + 273.15 if q.get('kind') == 'fraction': return value * 100.0 if unit in ('% w/w', '%') else value * 1000.0 if unit == 'g/kg' else value if q.get('kind') == 'density': return value if unit == 'g/cm³' else value * 1000.0 if unit == 'kg/m³' else value return value def fmt_value(profile, field, value, ap=None): q = profile['quantities'].get(field['q'], {}) if value is None: return '---' if q.get('kind') != 'text' else '' if q.get('kind') in ('text',): return str(value) v = to_unit(q, value, field.get('unit') or q.get('unit')) d = int(field.get('digits', q.get('digits', 2))) x = math.floor(abs(v) * 10 ** d + 0.5 + 1e-9) / 10 ** d s = f'{math.copysign(x, v) if x else 0.0:.{d}f}' if ap is not None and ap['settings'].get('region.data_format') in ('Deutsch (Deutschland)', 'Français (France)'): s = s.replace('.', ',') return s def from_input_temperature(ap, v): """A temperature typed in the input unit (abm p.42) -> degC.""" u = ap['settings'].get('units.temperature', '°C') return v if u == '°C' else (v - 32.0) * 5.0 / 9.0 if u == '°F' else v - 273.15 def to_input_temperature(ap, c): u = ap['settings'].get('units.temperature', '°C') return c if u == '°C' else c * 9.0 / 5.0 + 32.0 if u == '°F' else c + 273.15 # ---------------------------------------------------------------- user functions (abm 14.1 p.94-99, gsf 9.2 p.34-37) _ALLOWED = {ast.Expression, ast.BinOp, ast.UnaryOp, ast.Constant, ast.Name, ast.Load, ast.Call, ast.Add, ast.Sub, ast.Mult, ast.Div, ast.Pow, ast.USub, ast.UAdd} _FUNCS = {'log': math.log10, 'ln': math.log, 'sqrt': math.sqrt, 'sin': math.sin, 'cos': math.cos, 'tan': math.tan, 'asin': math.asin, 'acos': math.acos, 'atan': math.atan} def formula_ok(text, names): try: tree = ast.parse(text.replace('^', '**'), mode='eval') except SyntaxError: return False for n in ast.walk(tree): if type(n) not in _ALLOWED: return False if isinstance(n, ast.Call) and not (isinstance(n.func, ast.Name) and n.func.id in _FUNCS and len(n.args) == 1 and not n.keywords): return False if isinstance(n, ast.Name) and n.id not in names and n.id not in _FUNCS: return False return True def formula_eval(text, env): tree = ast.parse(text.replace('^', '**'), mode='eval') def ev(n): if isinstance(n, ast.Expression): return ev(n.body) if isinstance(n, ast.Constant): return float(n.value) if isinstance(n, ast.Name): return float(env[n.id]) if isinstance(n, ast.UnaryOp): return -ev(n.operand) if isinstance(n.op, ast.USub) else ev(n.operand) if isinstance(n, ast.Call): return _FUNCS[n.func.id](ev(n.args[0])) a, b = ev(n.left), ev(n.right) return {ast.Add: lambda: a + b, ast.Sub: lambda: a - b, ast.Mult: lambda: a * b, ast.Div: lambda: a / b, ast.Pow: lambda: a ** b}[type(n.op)]() return ev(tree) def function_value(fn, values, constants=None): """Output of one user function from the quantities of a result (None when an input is missing or the calculation fails).""" try: t = fn['type'] if t == 'Constant': return float((constants or {}).get(fn['name'], fn.get('value', 0.0))) xs = [values.get(q) for q in fn.get('inputs', [])] if any(x is None for x in xs): return None if t == 'Linear Function': return fn['offset'] + fn['factor'] * xs[0] if t == 'Polynomial (1D)': return sum(c * xs[0] ** i for i, c in enumerate(fn['coefficients'])) if t == 'Polynomial (2D)': x, y = xs[0], xs[1] c = fn['coefficients'] # order: 00 01 02 03 10 11 12 20 21 30 (gsf p.36) terms = [1, y, y * y, y ** 3, x, x * y, x * y * y, x * x, x * x * y, x ** 3] return sum(a * b for a, b in zip(c, terms)) if t == 'Table': pts = sorted(fn['table']) x = xs[0] if not pts or not pts[0][0] <= x <= pts[-1][0]: return None # interpolates, never extrapolates (gsf p.36) for (x0, y0), (x1, y1) in zip(pts, pts[1:]): if x0 <= x <= x1: return y0 + (y1 - y0) * (x - x0) / (x1 - x0) if x1 > x0 else y0 return pts[0][1] if t == 'Formula': env = {n: x for n, x in zip(fn['variables'], xs)} return formula_eval(fn['formula'], env) except (ValueError, ZeroDivisionError, OverflowError, KeyError, IndexError, TypeError): return None return None # ---------------------------------------------------------------- data memory def record_values(profile, ap, values, m): out = dict(values) out.update(profile.get('extra_values', lambda a, v: {})(ap, out)) for fn in ap['functions']: out['fn:' + fn['name']] = function_value(fn, out, m.get('constants') if m else None) return out def store_record(host, rec): """Store a result in the data memory (capacity, reminder, circular buffer; abm p.87, gsf p.25).""" ap, prof = host.ap, host.AP_PROFILE if ap['settings'].get('security.non_storage'): # gsf p.29-30: non storage mode, results are not stored rec = dict(rec, id=ap['next_data'], uid=f'{prof["serial"]}-{ap["unique"]:06d}', exported=False, signatures={}, comments=[], transient=True) ap['next_data'] += 1 ap['unique'] += 1 return rec cap = prof['memory_capacity'] if len(ap['data']) >= cap: if ap['settings']['memory.auto_delete'] and not ap['settings']['security.increased']: del ap['data'][:100] else: add_message(host, 'error', 'Data memory is full. No further results can be stored.') return None rec = dict(rec, id=ap['next_data'], uid=f'{prof["serial"]}-{ap["unique"]:06d}', exported=False, signatures=dict(submitter=None, reviewer=None, approver=None), comments=[]) ap['next_data'] += 1 ap['unique'] += 1 ap['data'].append(rec) if len(ap['data']) >= prof['memory_reminder']: add_message(host, 'warning', 'Data memory almost full. Please delete measured data.') return rec def _match(host, rec, c): crit, comp, val = c['criterion'], c['comparator'], c.get('value', '') prof = host.AP_PROFILE if crit == 'Print/Export Status': return rec['exported'] if comp == 'printed/exported' else not rec['exported'] if crit == 'Date Range': d = datetime.datetime.fromisoformat(rec['time']).date() today = device_dt(host).date() span = {'Today': (today, today), 'Yesterday': (today - datetime.timedelta(days=1),) * 2, 'Last Week': (today - datetime.timedelta(days=7), today), 'Last Month': (today - datetime.timedelta(days=31), today)}[val] inside = span[0] <= d <= span[1] return inside if comp == 'equals' else not inside if crit == 'Measuring Value': x = rec['values'].get(prof['main_quantity']) try: ref = float(val) except (TypeError, ValueError): return False if x is None: return False return {'larger than': x > ref, 'smaller than': x < ref, 'equals': abs(x - ref) < 1e-12, 'not equal': abs(x - ref) >= 1e-12}.get(comp, False) field = {'Sample Name': 'sample_name', 'Method': 'method', 'User': 'user', 'Sample Error State': 'error_state', 'Master Condition': 'condition'}[crit] s = str(rec.get(field, '')) return {'equals': s == val, 'not equal': s != val, 'containing': str(val).lower() in s.lower(), 'not containing': str(val).lower() not in s.lower()}.get(comp, False) def filtered(host, view, records=None): ap = host.ap recs = ap['data'] if records is None else records return [r for r in recs if all(_match(host, r, c) for c in ap['filters'][view])] def statistics(host): """Statistics per method over the filtered measured data, scans and checks excluded (abm p.91, gsf p.26-27).""" ap, prof = host.ap, host.AP_PROFILE out = [] recs = [r for r in filtered(host, 'view') if r['kind'] == 'measurement' and not r.get('sub')] for name in sorted({r['method'] for r in recs}): m = method(ap, name) qs = [f['q'] for f in (m['output'] if m else [])] or list(ap['browser']) qs = [q for q in qs if prof['quantities'].get(q, {}).get('kind') not in ('text', None) or q.startswith('fn:')] rows = [] for q in qs: xs = [r['values'][q] for r in recs if r['method'] == name and isinstance(r['values'].get(q), (int, float))] if not xs: continue avg = sum(xs) / len(xs) sd = math.sqrt(sum((x - avg) ** 2 for x in xs) / (len(xs) - 1)) if len(xs) > 1 else 0.0 rows.append(dict(q=q, label=quantity_label(prof, ap, q), n=len(xs), min=min(xs), max=max(xs), avg=avg, sd=sd)) out.append(dict(method=name, n=len([r for r in recs if r['method'] == name]), quantities=rows)) return out def quantity_label(profile, ap, q): if q.startswith('fn:'): return q[3:] return profile['quantities'].get(q, {}).get('label', q) # ---------------------------------------------------------------- the commands of the device layer def _caps(): """Device-layer commands: (input_schema, output_schema, meaning_zh, kind, right, example, effects).""" method_name = dict(NAME) entry = obj(dict(name={'type': 'string', 'minLength': 0, 'maxLength': 50}, method=NAME, type={'type': 'string', 'enum': list(MEASUREMENT_TYPES)}, field1={'type': 'string', 'maxLength': 30}, field2={'type': 'string', 'maxLength': 30}, field3={'type': 'string', 'maxLength': 30}), optional=('type', 'field1', 'field2', 'field3')) criterion = obj(dict(criterion={'type': 'string', 'enum': list(FILTER_CRITERIA)}, comparator={'type': 'string', 'enum': list(COMPARATORS)}, value={'type': 'string', 'maxLength': 50}), optional=('value',)) fn = obj(dict(name=NAME, type={'type': 'string', 'enum': list(FUNCTION_TYPES)}, quantity={'type': 'string', 'maxLength': 40}, unit={'type': 'string', 'maxLength': 20}, comment={'type': 'string', 'maxLength': 100}, protected=BOOL, inputs={'type': 'array', 'items': STR, 'maxItems': 2}, variables={'type': 'array', 'items': STR, 'maxItems': 2}, value=num('1'), offset=num('1'), factor=num('1'), coefficients={'type': 'array', 'items': num('1'), 'maxItems': 10}, table={'type': 'array', 'items': {'type': 'array', 'items': num('1'), 'minItems': 2, 'maxItems': 2}, 'maxItems': 1000}, formula={'type': 'string', 'maxLength': 200}), optional=('quantity', 'unit', 'comment', 'protected', 'inputs', 'variables', 'value', 'offset', 'factor', 'coefficients', 'table', 'formula')) return { 'settings.configure': (obj(dict(settings=ANYOBJ)), obj(dict(settings=ANYOBJ)), '修改仪器设置（控制面板、打印、样品列表选项、数据存储、系统安全）；按设置表校验，' '改语言/数据格式/键盘时仪器重启', 'configuration', None, {'settings': {'control.brightness': 80}}, ['device.settings']), 'clock.set': (obj(dict(date={'type': 'string', 'pattern': r'^\d{4}-\d{2}-\d{2}$'}, time={'type': 'string', 'pattern': r'^\d{2}:\d{2}$'}), optional=('date', 'time')), obj(dict(datetime=STR)), '设定仪器日期与时间（Setup > Control Panel > Date and Time）', 'configuration', 'setup_control_panel', {'time': '09:30'}, ['device.datetime']), 'user.logon': (obj(dict(user=NAME, password={'type': 'string', 'maxLength': 30})), obj(dict(user=STR)), '登录（标题栏用户图标）：用户名与密码；增强安全下三次失败锁定账户', 'device_command', None, {'user': 'Operator', 'password': 'operator'}, ['device.users']), 'user.logoff': (obj({}), obj(dict(user=nullable(STR))), '注销；若有自动登录用户则其自动登录，否则锁定直到有人登录', 'device_command', None, {}, ['device.users']), 'users.save': (obj(dict(name=NAME, original=nullable(STR), group=NAME, active=BOOL, auto_logon=BOOL, role={'type': 'string', 'enum': list(SIGN_ROLES)}, sign_name={'type': 'string', 'maxLength': 40}, email={'type': 'string', 'maxLength': 64}, email_active=BOOL), optional=('original', 'role', 'sign_name', 'email', 'email_active')), obj(dict(name=STR)), '新建或编辑用户账户（激活、自动登录、用户名、用户组、电子签名角色、邮件）', 'configuration', 'setup_users', {'name': 'Analyst', 'group': 'Operator', 'active': True, 'auto_logon': False}, ['device.users']), 'users.delete': (obj(dict(name=NAME)), obj(dict(name=STR)), '删除用户账户（不能删除自己或更高权限组的账户）', 'configuration', 'setup_users', {'name': 'Analyst'}, ['device.users']), 'users.set_password': (obj(dict(name=NAME, password={'type': 'string', 'maxLength': 30})), obj(dict(name=STR)), '设定/修改密码（每个用户可改自己的；管理员可改所有人）', 'configuration', None, {'name': 'Operator', 'password': 'secret1'}, ['device.users']), 'groups.manage': (obj(dict(action={'type': 'string', 'enum': ['copy', 'rename', 'delete', 'icon', 'rights']}, group=NAME, name=NAME, icon={'type': 'string', 'enum': list(GROUP_ICONS)}, rights={'type': 'array', 'items': {'type': 'string', 'enum': list(RIGHTS)}}), optional=('name', 'icon', 'rights')), obj(dict(group=STR)), '用户组管理：复制标准组为自定义组、改名、改图标、改权限、删除自定义组', 'configuration', 'setup_users', {'action': 'copy', 'group': 'Operator'}, ['device.users']), 'messages.acknowledge': (obj(dict(id=nullable(num('1', 1, integer=True)))), obj(dict(remaining=num('1', 0, integer=True))), '确认消息列表中的一条（X）或全部（Delete all）', 'device_command', None, {'id': None}, ['device.messages']), 'favorites.configure': (obj(dict(action={'type': 'string', 'enum': ['add', 'rename', 'delete', 'move_up', 'move_down']}, page=STR, name=NAME), optional=('name',)), obj(dict(count=num('1', 0, integer=True))), '收藏夹：添加（对话框标题栏的收藏键）、改名、删除、排序（固定收藏不能删改）', 'configuration', 'favorites', {'action': 'add', 'page': 'quick_settings', 'name': 'Quick Settings'}, ['device.favorites']), 'methods.select': (obj(dict(method=method_name)), obj(dict(method=STR)), '选择方法（主屏）：方法温度等写入快速设置并下发到测量单元', 'device_command', 'method_select', {'method': 'Refractive Index'}, ['methods.active', 'sample.quick_settings']), 'methods.configure': (obj(dict(method=method_name, settings=ANYOBJ)), obj(dict(method=STR)), '修改方法设置（测量模式、测量模块参数、显示布局、输出字段、结果输出、限值、快速设置参数、模块/常数）', 'configuration', 'method_settings', {'method': 'Refractive Index', 'settings': {'mode': 'S'}}, ['methods.list']), 'methods.manage': (obj(dict(action={'type': 'string', 'enum': ['copy', 'rename', 'delete', 'move_up', 'move_down', 'visibility', 'show_all', 'hide_all']}, method=method_name, name=NAME, visible=BOOL), optional=('name', 'visible')), obj(dict(method=STR)), '方法管理：复制、改名、删除、可见性与排序（当前方法不能删除/改名）', 'configuration', 'method_management', {'action': 'copy', 'method': 'Refractive Index'}, ['methods.list']), 'quick.configure': (obj(dict(settings=ANYOBJ)), obj(dict(settings=ANYOBJ)), '快速设置（主屏）：样品名、测量类型与本次测量参数，' '保留到下次修改', 'configuration', 'quick_settings', {'settings': {'sample_name': 'S1'}}, ['sample.quick_settings']), 'sample_list.edit': (obj(dict(action={'type': 'string', 'enum': ['add', 'update', 'delete', 'clear', 'save', 'load', 'rename']}, index=num('1', 0, 199, integer=True), entry=entry, template=num('1', 0, 9, integer=True), name=NAME), optional=('index', 'entry', 'template', 'name')), obj(dict(count=num('1', 0, integer=True))), '样品列表：添加/编辑/删除样品，列表管理保存/载入/改名模板与清空', 'configuration', 'sample_list', {'action': 'clear'}, ['sample.list', 'device.messages']), 'measurement.start': (obj({}), obj(dict(phase=STR, operation_id=STR)), '按当前方法与快速设置开始测量（主屏）：等待恒温、保持时间、' '按精度设定的稳定时间读数，超时中止；MM多次、MF多次装样、TS温度扫描、C核查；结果存入数据存储', 'device_command', 'measure', {}, ['cycle.phase', 'run.state']), 'measurement.continue': (obj({}), obj(dict(phase=STR)), 'MF多次装样：换样后确认继续下一次测量', 'device_command', 'measure', {}, ['run.state', 'cycle.phase']), 'monitor.set': (obj(dict(active=BOOL)), obj(dict(active=BOOL)), '监视模式（快捷区）：实时显示读数/解冻结果', 'device_command', 'monitor', {'active': True}, ['display.readout']), 'data.filter': (obj(dict(view={'type': 'string', 'enum': ['view', 'delete']}, action={'type': 'string', 'enum': ['add', 'delete', 'clear']}, criterion=criterion, index=num('1', 0, 7, integer=True)), optional=('criterion', 'index')), obj(dict(count=num('1', 0, integer=True))), '数据存储筛选（：添加条件、比较符、值；删除一条或全部；条件之间为AND）', 'configuration', 'data_view', {'view': 'view', 'action': 'clear'}, ['data.filters']), 'data.delete': (obj(dict(kind={'type': 'string', 'enum': ['measured', 'check']}, id=nullable(num('1', 1, integer=True)))), obj(dict(deleted=num('1', 0, integer=True))), '删除测量/核查数据：单条（Details > Delete）或按删除筛选的全部（Delete All）', 'device_command', 'data_delete', {'kind': 'measured', 'id': None}, ['data.measured', 'data.checks']), 'data.sign': (obj(dict(id=num('1', 1, integer=True), positive=BOOL, comment={'type': 'string', 'maxLength': 100}, password={'type': 'string', 'maxLength': 30}), optional=('comment', 'password')), obj(dict(signatures=ANYOBJ)), '电子签名：按用户角色对单条测量结果签署正/负（只能签一次）', 'device_command', 'data_view', {'id': 1, 'positive': True}, ['data.measured']), 'audit.delete': (obj({}), obj(dict(deleted=num('1', 0, integer=True))), '删除审计追踪中已导出的条目（未导出的不能删除）', 'device_command', 'data_delete', {}, ['data.audit_trail']), 'lists.edit': (obj(dict(list={'type': 'string', 'enum': ['printers', 'reports', 'browser', 'shares', 'extrapolation']}, action={'type': 'string', 'enum': ['save', 'delete', 'move_up', 'move_down']}, index=nullable(num('1', 0, integer=True)), item=ANYOBJ), optional=('index', 'item')), obj(dict(count=num('1', 0, integer=True))), '配置列表：打印机管理、报表管理、数据浏览列、网络共享（FTP连接）', 'configuration', None, {'list': 'browser', 'action': 'move_up', 'index': 1}, ['device.lists']), 'functions.save': (obj(dict(function=fn, original=nullable(STR)), optional=('original',)), obj(dict(name=STR)), '用户函数：新建/编辑常数、公式、线性、一维/二维多项式、表格（输出量可作结果字段）', 'configuration', 'user_functions', {'function': {'name': 'Offset', 'type': 'Constant', 'value': 0.0}}, ['functions.list']), 'functions.delete': (obj(dict(name=NAME)), obj(dict(name=STR)), '删除用户函数（被方法限值使用时不能删除）', 'configuration', 'user_functions', {'name': 'Offset'}, ['functions.list']), 'calculator.evaluate': (obj(dict(function=NAME, inputs={'type': 'array', 'items': num('1'), 'maxItems': 2})), obj(dict(value=nullable(num('1')))), '计算器：输入值计算用户函数的输出', 'device_command', 'user_functions', {'function': 'Offset', 'inputs': []}, ['functions.calculator']), 'calculator.group': (obj(dict(inputs={'type': 'object', 'additionalProperties': num('1')})), obj(dict(values={'type': 'object'})), '组计算器：输入各输入量的值，一次算出全部用户函数', 'device_command', 'user_functions', {'inputs': {}}, ['functions.calculator']), 'functions.table_edit': (obj(dict(name=NAME, action={'type': 'string', 'enum': ['add', 'delete']}, x=num('1'), y=num('1'), index=num('1', 0, 999, integer=True)), optional=('x', 'y', 'index')), obj(dict(pairs=num('1', 0, integer=True))), '用户表格函数：逐行添加/删除数据对（只插值，不外推）', 'configuration', 'user_functions', {'name': 'Table 1', 'action': 'add', 'x': 1.33, 'y': 0.0}, ['functions.list']), 'checks.manage': (obj(dict(action={'type': 'string', 'enum': ['save', 'delete']}, check=ANYOBJ, original=nullable(STR)), optional=('original',)), obj(dict(name=STR)), '核查管理：核查名称、类型、方法/参考标准、是否GxP相关、提醒间隔、到期禁止测量、容差', 'configuration', 'check_settings', {'action': 'delete', 'check': {'name': 'x'}}, ['checks.list']), 'standards.manage': (obj(dict(action={'type': 'string', 'enum': ['save', 'delete']}, standard=ANYOBJ, original=nullable(STR)), optional=('original',)), obj(dict(name=STR)), '参考标准管理：名称、参考温度、参考值、批号/证书号/有效期', 'configuration', 'check_settings', {'action': 'delete', 'standard': {'name': 'x'}}, ['standards.list']), 'check.start': (obj(dict(check=NAME)), obj(dict(phase=STR, operation_id=STR)), '执行核查（Checks / Adjustments > Checks Execution）：' '测量参考物质并与参考值比较，结果存入核查数据', 'device_command', 'checks', {'check': 'Water Check'}, ['run.state', 'cycle.phase']), 'touchscreen.calibrate': (obj(dict(points={'type': 'array', 'items': {'type': 'array', 'items': num('px'), 'minItems': 2, 'maxItems': 2}, 'minItems': 4, 'maxItems': 4})), obj(dict(calibrated=BOOL)), '触摸屏校准：依次点四个十字，接受新校准', 'device_command', 'setup_control_panel', {'points': [[40, 40], [760, 40], [760, 440], [40, 440]]}, ['device.touch_calibration']), 'firmware.check': (obj({}), obj(dict(up_to_date=BOOL)), '模块固件更新（Internal）：检查各模块固件版本，均为最新时不改动', 'device_command', 'service', {}, ['device.system']), } DEVICE_CAPS = _caps() FREE_WHILE_RUNNING = ('monitor.set', 'favorites.configure', 'data.filter', 'calculator.evaluate', 'calculator.group', 'firmware.check', 'messages.acknowledge', 'user.logon', 'user.logoff', 'measurement.continue') NO_LOGON = ('user.logon', 'user.logoff', 'messages.acknowledge') def right_of(host, cap, args): if cap == 'users.set_password' and args.get('name', '').lower() == str(host.ap['user']).lower(): return None # every user may change the own password (abm p.49) if cap == 'lists.edit': return {'printers': 'setup_printout', 'reports': 'setup_printout', 'browser': 'data_settings', 'shares': 'setup_control_panel', 'extrapolation': 'setup_measuring'}[args['list']] if cap == 'methods.configure': return 'output_fields' if set(args['settings']) <= {'fields', 'set_field'} else 'method_settings' if cap in DEVICE_CAPS: return DEVICE_CAPS[cap][4] return host.AP_PROFILE.get('rights', {}).get(cap) def gate(host, cap, args): """Power, logon, rights and measurement locks of a device command (abm p.32: settings cannot be saved while a measurement runs).""" ap = host.ap need(host.powered, 'POWER_OFF') if cap in NO_LOGON: return need(ap['user'] is not None, 'LOGON_REQUIRED') right = right_of(host, cap, args) if right: need(has_right(ap, right), 'PERMISSION_DENIED') if cap not in FREE_WHILE_RUNNING: need(host.phase != 'running' and (ap['run'] is None or cap in host.AP_PROFILE.get('free_while_run', ())), 'BUSY') def device_invoke(host, cap, args): """Run one device-layer command on a candidate copy of host.ap and commit it when it succeeds (a _Keep refusal keeps its device-side counters, e.g. failed logons).""" check(host.AP_CAPS[cap][0], args) gate(host, cap, args) handler = _HANDLERS.get(cap) or host.AP_PROFILE['handlers'][cap] saved = host.ap host.ap = copy.deepcopy(saved) try: out = handler(host, args) except _Keep as exc: host.revision += 1 raise ActionRejected(str(exc)) from None except BaseException: host.ap = saved raise if cap not in ('calculator.evaluate', 'calculator.group'): host.revision += 1 return out # ---- handlers def _settings(host, a): ap, prof = host.ap, host.AP_PROFILE defs = {f['key']: f for f in prof['settings']} ch = a['settings'] need(bool(ch), 'INVALID_ARGUMENT') for k, v in ch.items(): f = defs.get(k) need(f is not None and value_ok(f, v), 'INVALID_ARGUMENT') right = SECTION_RIGHT.get(f['section'], prof.get('section_rights', {}).get(f['section'], 'setup_measuring')) need(has_right(ap, right), 'PERMISSION_DENIED') old = dict(ap['settings']) new = dict(old, **copy.deepcopy(ch)) if 'security.level' in ch and ch['security.level'] != old['security.level']: if ch['security.level'] in SECURITY_LEVELS: for k, v in SECURITY_LEVELS[ch['security.level']].items(): if k in new and k not in ch: new[k] = v ap['sample_list'] = [] # abm p.53: the current sample list is reset elif any(k in ch for k in ('security.audit_trail', 'security.esign', 'security.auto_logoff', 'security.pw_expiry', 'security.increased')): lvl = next((n for n, d in SECURITY_LEVELS.items() if all(new.get(k) == v for k, v in d.items() if k in ('security.audit_trail', 'security.auto_logoff', 'security.pw_expiry', 'security.increased'))), 'User-defined') new['security.level'] = lvl # abm p.52: any change of a standard setting -> user-defined level if new.get('security.increased') and not old.get('security.increased'): for u in ap['users']: # abm p.54: accounts not complying with the rules are deactivated if len(u['name']) < 6 or len(u['password']) < 6: u['active'] = False u['auto_logon'] = False ap['settings'] = new for k in ch: if old.get(k) != new.get(k): audit(host, f'Setting "{defs[k]["label"]}" changed from {old.get(k)!r} to {new.get(k)!r}') if any(defs[k].get('reboot') and old.get(k) != new.get(k) for k in ch): ap['reboot_pending'] = True # abm p.41: the instrument reboots after confirmation _reboot(host) return dict(settings={k: new[k] for k in ch}) def _reboot(host): ap = host.ap ap['power_epoch'] += 1 ap['reboot_pending'] = False ap['user'] = auto_logon_user(ap) ap['boot_s'] = host.time_s ap['sample_list'] = [] # abm p.82: cleared when the instrument is switched off def _clock(host, a): need('date' in a or 'time' in a, 'INVALID_ARGUMENT') cur = device_dt(host) try: d = datetime.date.fromisoformat(a['date']) if 'date' in a else cur.date() hh, mm = (int(x) for x in a['time'].split(':')) if 'time' in a else (cur.hour, cur.minute) new = datetime.datetime(d.year, d.month, d.day, hh, mm, 0 if 'time' in a else cur.second) except ValueError: raise ActionRejected('INVALID_ARGUMENT') from None host.ap['clock_offset_s'] = (new - EPOCH0).total_seconds() - host.time_s audit(host, f'Date and time changed to {new.isoformat()}') return dict(datetime=device_iso(host)) def _pw_equal(host, stored, given): if host.AP_PROFILE.get('password_case_sensitive', True): return stored == given return stored.lower() == given.lower() # abm p.48: passwords are not case sensitive (Abbemat 350/550) def _logon(host, a): ap = host.ap u = user_record(ap, a['user']) need(u is not None, 'WRONG_PASSWORD') need(u['active'], 'ACCOUNT_LOCKED') if u['password'] and not _pw_equal(host, u['password'], a['password']): u['failed'] += 1 audit(host, f'Incorrect password for user {u["name"]}') if ap['settings']['security.increased'] and u['failed'] >= 3: # abm p.33: deactivated after three failed attempts u['active'] = False # the failed attempt and the lock are kept although the logon fails raise _Keep('ACCOUNT_LOCKED') raise _Keep('WRONG_PASSWORD') u['failed'] = 0 ap['user'] = u['name'] ap['last_input_s'] = host.time_s audit(host, f'User {u["name"]} logged on') return dict(user=u['name']) class _Keep(ActionRejected): """A refusal whose side effects are part of the device behaviour (failed logon counter, account lock).""" def _logoff(host, a): ap = host.ap audit(host, f'User {ap["user"]} logged off') ap['user'] = auto_logon_user(ap) return dict(user=ap['user']) def _users_save(host, a): ap = host.ap inc = ap['settings']['security.increased'] orig = a.get('original') g = group_record(ap, a['group']) need(g is not None, 'NOT_FOUND') need(all(32 <= ord(c) < 127 for c in a['name']), 'INVALID_ARGUMENT') # ASCII names (abm p.47) need(not inc or len(a['name']) >= 6, 'NOT_ALLOWED') # abm p.48: at least 6 characters with increased security need(not (a['auto_logon'] and (inc or ap['settings']['security.audit_trail'])), 'NOT_ALLOWED') clash = user_record(ap, a['name']) if orig is None: need(clash is None, 'IN_USE') need(len(ap['users']) < host.AP_PROFILE.get('max_users', 50), 'NOT_ALLOWED') u = dict(name=a['name'], group=a['group'], password='', active=a['active'], auto_logon=False, role='None', sign_name='', email='', email_active=False, failed=0, history=[]) ap['users'].append(u) else: u = user_record(ap, orig) need(u is not None, 'NOT_FOUND') need(clash is None or clash is u, 'IN_USE') if ap['user'] and u['name'].lower() == ap['user'].lower(): ap['user'] = a['name'] u.update(name=a['name'], group=a['group'], active=a['active']) if a['auto_logon']: for x in ap['users']: x['auto_logon'] = False # one auto logon user (abm p.48) u['auto_logon'] = a['auto_logon'] for k in ('role', 'sign_name', 'email', 'email_active'): if k in a: u[k] = a[k] if a['active']: u['failed'] = 0 audit(host, f'User account {u["name"]} {"created" if orig is None else "changed"}') return dict(name=u['name']) def _level(ap, group): g = group_record(ap, group) return {'Administrator': 3, 'Manager': 2, 'Operator': 1}.get(g['base'] if g else 'Operator', 1) def _users_delete(host, a): ap = host.ap u = user_record(ap, a['name']) need(u is not None, 'NOT_FOUND') need(u['name'].lower() != str(ap['user']).lower(), 'NOT_ALLOWED') # not the own account (abm p.49) me = user_record(ap, ap['user']) need(_level(ap, u['group']) <= _level(ap, me['group']), 'NOT_ALLOWED') ap['users'].remove(u) audit(host, f'User account {u["name"]} deleted') return dict(name=u['name']) def _users_password(host, a): ap = host.ap u = user_record(ap, a['name']) need(u is not None, 'NOT_FOUND') pw = a['password'] s = ap['settings'] need(all(32 <= ord(c) < 127 for c in pw), 'INVALID_ARGUMENT') if s['security.increased'] or s['security.level'] == '21 CFR Part 11': need(len(pw) >= 6, 'NOT_ALLOWED') # abm p.48 need(pw not in u['history'][-5:], 'NOT_ALLOWED') # the last 5 passwords cannot be reused if s['security.pw_min_active']: need(len(pw) >= s['security.pw_min_length'], 'NOT_ALLOWED') u['history'] = (u['history'] + [u['password']])[-5:] if u['password'] else u['history'] u['password'] = pw audit(host, f'Password of user {u["name"]} changed') return dict(name=u['name']) def _groups(host, a): ap = host.ap g = group_record(ap, a['group']) need(g is not None, 'NOT_FOUND') act = a['action'] if act == 'copy': need(g['base'] in ('Manager', 'Operator'), 'NOT_ALLOWED') # gsf p.18: copies of manager / operator groups n = 1 while group_record(ap, f'{g["name"]} ({n})'): n += 1 new = dict(name=a.get('name') or f'{g["name"]} ({n})', base=g['base'], icon='Icon 4', rights=list(g['rights']), standard=False) need(group_record(ap, new['name']) is None, 'IN_USE') ap['groups'].append(new) audit(host, f'User group {new["name"]} created') return dict(group=new['name']) need(not g['standard'], 'NOT_ALLOWED') # standard groups cannot be edited or deleted (gsf p.18) if act == 'rename': need('name' in a and group_record(ap, a['name']) is None, 'IN_USE') for u in ap['users']: if u['group'] == g['name']: u['group'] = a['name'] g['name'] = a['name'] elif act == 'icon': need('icon' in a, 'INVALID_ARGUMENT') g['icon'] = a['icon'] elif act == 'rights': need('rights' in a, 'INVALID_ARGUMENT') base = set(RIGHTS) if g['base'] == 'Administrator' else set(MANAGER_RIGHTS if g['base'] == 'Manager' else OPERATOR_RIGHTS) need(set(a['rights']) <= base, 'NOT_ALLOWED') # custom groups are based on the manager / operator rights g['rights'] = [r for r in RIGHTS if r in a['rights']] else: need(not any(u['group'] == g['name'] for u in ap['users']), 'IN_USE') ap['groups'].remove(g) audit(host, f'User group {g["name"]} changed ({act})') return dict(group=g['name']) def _ack(host, a): ap = host.ap if a['id'] is None: ap['messages'] = [] else: need(any(m['id'] == a['id'] for m in ap['messages']), 'NOT_FOUND') ap['messages'] = [m for m in ap['messages'] if m['id'] != a['id']] return dict(remaining=len(ap['messages'])) def _favorites(host, a): ap, prof = host.ap, host.AP_PROFILE fixed = [f['page'] for f in prof.get('fixed_favorites', [])] pages = [f['page'] for f in ap['favorites']] act, page = a['action'], a['page'] need(page in prof['favorite_pages'] or page in fixed, 'INVALID_ARGUMENT') if act == 'add': need(page not in pages, 'IN_USE') need(len(pages) < 30, 'NOT_ALLOWED') ap['favorites'].append(dict(page=page, name=a.get('name') or page)) return dict(count=len(ap['favorites'])) need(page in pages, 'NOT_FOUND') i = pages.index(page) if act in ('rename', 'delete'): need(page not in fixed, 'NOT_ALLOWED') # abm p.36: Message List / Monitor Mode cannot be renamed or deleted if act == 'rename': need(bool(a.get('name')), 'INVALID_ARGUMENT') ap['favorites'][i]['name'] = a['name'] elif act == 'delete': del ap['favorites'][i] else: j = i - 1 if act == 'move_up' else i + 1 need(0 <= j < len(pages), 'NOT_ALLOWED') ap['favorites'][i], ap['favorites'][j] = ap['favorites'][j], ap['favorites'][i] return dict(count=len(ap['favorites'])) def _select(host, a): ap, prof = host.ap, host.AP_PROFILE m = method(ap, a['method']) need(m is not None and m['visible'], 'NOT_FOUND') ap['active'] = m['name'] ap['quick'] = dict(quick_from_method(prof, m), sample_name=ap['quick']['sample_name'], field1=ap['quick']['field1'], field2=ap['quick']['field2'], field3=ap['quick']['field3']) prof['apply_method'](host, m, ap['quick']) audit(host, f'Method changed to {m["name"]}') return dict(method=m['name']) def method_keys(profile): """Schema of methods.configure settings: instrument module fields plus the generic method parts.""" qids = list(profile['quantities']) fld = obj(dict(q={'type': 'string', 'minLength': 1, 'maxLength': 60}, unit={'type': 'string', 'maxLength': 20}, digits=num('1', 0, 6, integer=True)), optional=('unit', 'digits')) lim = obj(dict(q={'type': 'string', 'minLength': 1, 'maxLength': 60}, lower=nullable(num('1')), upper=nullable(num('1')))) props = {f['key']: field_schema(f) for f in profile['method_fields']} props.update(mode={'type': 'string', 'enum': [k for k in MEASUREMENT_TYPES if k in profile['modes']]}, mm_count=num('1', 2, 10, integer=True), mf_count=num('1', 2, profile.get('mf_max', 5), integer=True), ts_start=num('°C', profile['t_min_c'], profile['t_max_c']), ts_step=num('°C', 0.01, profile['t_max_c'] - profile['t_min_c']), ts_end=num('°C', profile['t_min_c'], profile['t_max_c']), check=nullable(NAME), layout={'type': 'string', 'enum': [x[0] for x in profile['layouts']]}, fields={'type': 'array', 'items': fld, 'maxItems': 8}, output={'type': 'array', 'items': fld, 'maxItems': 30}, limits={'type': 'array', 'items': lim, 'maxItems': 20}, quick={'type': 'array', 'items': {'type': 'string', 'enum': list(profile['quick_params'])}, 'maxItems': 20}, modules={'type': 'object', 'additionalProperties': BOOL}, constants={'type': 'object', 'additionalProperties': num('1')}, # row operations of the method dialogs (one row edited at a time: abm p.76-79) set_field=obj(dict(index=num('1', 0, 7, integer=True), q={'type': 'string', 'maxLength': 60}, unit={'type': 'string', 'maxLength': 20}, digits=num('1', 0, 6, integer=True)), optional=('unit', 'digits')), set_output=obj(dict(index=num('1', 0, 29, integer=True), q={'type': 'string', 'minLength': 1, 'maxLength': 60}, unit={'type': 'string', 'maxLength': 20}, digits=num('1', 0, 6, integer=True)), optional=('unit', 'digits')), delete_output=num('1', 0, 29, integer=True), move_output=obj(dict(index=num('1', 0, 29, integer=True), dir={'type': 'string', 'enum': ['up', 'down']})), set_limit=obj(dict(index=num('1', 0, 19, integer=True), q={'type': 'string', 'minLength': 1, 'maxLength': 60}, lower=nullable(num('1')), upper=nullable(num('1')))), delete_limit=num('1', 0, 19, integer=True), add_quick={'type': 'string', 'enum': list(profile['quick_params'])}, delete_quick={'type': 'string', 'enum': list(profile['quick_params'])}, move_quick=obj(dict(param={'type': 'string', 'enum': list(profile['quick_params'])}, dir={'type': 'string', 'enum': ['up', 'down']})), set_constant=obj(dict(name=NAME, value=num('1'))), set_module=obj(dict(name=NAME, active=BOOL))) props.update(_mode_keys(profile)) if 'TTS' in profile['modes']: # dma p.38: the temperature table of a method props.update(add_tts=num('°C', profile['t_min_c'], profile['t_max_c']), delete_tts=num('1', 0, 29, integer=True)) props.update(profile.get('method_keys_extra', {})) del qids return {'type': 'object', 'properties': props, 'additionalProperties': False, 'minProperties': 1} def _quantity_ok(profile, ap, q): return q in profile['quantities'] or (q.startswith('fn:') and any(f['name'] == q[3:] for f in ap['functions'])) or \ any(x['id'] == q for x in profile.get('extra_quantities', lambda a: [])(ap)) def _mconfigure(host, a): ap, prof = host.ap, host.AP_PROFILE m = method(ap, a['method']) need(m is not None and m['visible'], 'NOT_FOUND') need(not m['protected'] or a['settings'].keys() <= {'fields', 'set_field'}, 'NOT_ALLOWED') s = dict(a['settings']) check(method_keys(prof), s) s = _row_ops(prof, ap, m, s) for k in ('fields', 'output'): for f in s.get(k, []): need(_quantity_ok(prof, ap, f['q']), 'INVALID_ARGUMENT') q = prof['quantities'].get(f['q'], {}) need(not f.get('unit') or f['unit'] in q.get('units', []) or f['q'].startswith('fn:'), 'INVALID_ARGUMENT') for lim in s.get('limits', []): need(_quantity_ok(prof, ap, lim['q']), 'INVALID_ARGUMENT') need(lim['lower'] is None or lim['upper'] is None or lim['lower'] < lim['upper'], 'INVALID_ARGUMENT') if 'quick' in s: need(all(p in s['quick'] for p in prof['quick_locked']), 'NOT_ALLOWED') # abm p.79: Sample name and Type cannot be deleted if s.get('mode') == 'C' or ('check' in s and s['check'] is not None): c = s.get('check', m['check']) need(c is not None and any(x['name'] == c and (x.get('method') in (None, m['name'])) for x in ap['checks']), 'NOT_FOUND') if 'ts_start' in s or 'ts_end' in s or 'ts_step' in s: st, sp, en = s.get('ts_start', m['ts_start']), s.get('ts_step', m['ts_step']), s.get('ts_end', m['ts_end']) need(abs(en - st) / sp <= 200 + 1e-9, 'INVALID_ARGUMENT') for k, v in s.items(): if k in m['settings']: m['settings'][k] = copy.deepcopy(v) else: m[k] = copy.deepcopy(v) if 'layout' in s: # abm p.76: the fields of the previous layout move to the new one n = dict(prof['layouts'])[s['layout']] m['fields'] = (m['fields'] + [f for f in prof['default_fields'] if f['q'] not in [x['q'] for x in m['fields']]])[:n] while len(m['fields']) < n: m['fields'].append(dict(q='', unit='', digits=0)) prof.get('validate_method', lambda h, x: None)(host, m) if m['name'] == ap['active']: q = quick_from_method(prof, m) ap['quick'] = dict(q, sample_name=ap['quick']['sample_name'], field1=ap['quick']['field1'], field2=ap['quick']['field2'], field3=ap['quick']['field3']) prof['apply_method'](host, m, ap['quick']) audit(host, f'Method settings of {m["name"]} changed: {", ".join(sorted(s))}') return dict(method=m['name']) def _row_ops(prof, ap, m, s): """Turn the row operations of the method dialogs into whole-list settings (validated like a direct list).""" def item(x): q = prof['quantities'].get(x['q'], {}) return dict(q=x['q'], unit=x.get('unit', q.get('unit', '')), digits=x.get('digits', q.get('digits', 2))) if 'set_field' in s: x = s.pop('set_field') need(x['index'] < len(m['fields']), 'NOT_FOUND') fields = copy.deepcopy(m['fields']) fields[x['index']] = item(x) if x['q'] else dict(q='', unit='', digits=0) s['fields'] = fields out = copy.deepcopy(s.get('output', m['output'])) if 'set_output' in s: x = s.pop('set_output') need(x['index'] <= len(out), 'NOT_FOUND') if x['index'] == len(out): out.append(item(x)) # the empty row at the end adds an item (abm p.77) else: out[x['index']] = item(x) s['output'] = out if 'delete_output' in s: i = s.pop('delete_output') need(i < len(out), 'NOT_FOUND') del out[i] s['output'] = out if 'move_output' in s: x = s.pop('move_output') i, j = x['index'], x['index'] + (-1 if x['dir'] == 'up' else 1) need(i < len(out) and 0 <= j < len(out), 'NOT_ALLOWED') out[i], out[j] = out[j], out[i] s['output'] = out lim = copy.deepcopy(s.get('limits', m['limits'])) if 'set_limit' in s: x = s.pop('set_limit') need(x['index'] <= len(lim), 'NOT_FOUND') row = dict(q=x['q'], lower=x['lower'], upper=x['upper']) lim = lim[:x['index']] + [row] + lim[x['index'] + 1:] s['limits'] = lim if 'delete_limit' in s: i = s.pop('delete_limit') need(i < len(lim), 'NOT_FOUND') del lim[i] s['limits'] = lim qk = list(s.get('quick', m['quick'])) if 'add_quick' in s: p = s.pop('add_quick') need(p not in qk, 'IN_USE') qk.append(p) s['quick'] = qk if 'delete_quick' in s: p = s.pop('delete_quick') need(p in qk, 'NOT_FOUND') qk.remove(p) s['quick'] = qk if 'move_quick' in s: x = s.pop('move_quick') need(x['param'] in qk, 'NOT_FOUND') i = qk.index(x['param']) j = i + (-1 if x['dir'] == 'up' else 1) need(0 <= j < len(qk), 'NOT_ALLOWED') qk[i], qk[j] = qk[j], qk[i] s['quick'] = qk if 'set_constant' in s: x = s.pop('set_constant') f = next((f for f in ap['functions'] if f['name'] == x['name'] and f['type'] == 'Constant'), None) need(f is not None, 'NOT_FOUND') s['constants'] = dict(s.get('constants', m['constants']), **{x['name']: x['value']}) if 'add_tts' in s: # dma p.38: the temperature table, one entry at a time tts = sorted(set(s.get('tts_temps', m['tts_temps'])) | {s.pop('add_tts')}, reverse=True) s['tts_temps'] = tts if 'delete_tts' in s: tts = list(s.get('tts_temps', m['tts_temps'])) i = s.pop('delete_tts') need(i < len(tts), 'NOT_FOUND') del tts[i] s['tts_temps'] = tts if 'set_module' in s: x = s.pop('set_module') s['modules'] = dict(s.get('modules', m['modules']), **{x['name']: x['active']}) for k, v in s.get('modules', {}).items(): # modules: the installed optional modules and the constants (abm p.79) need(k in prof.get('modules', []) or any(f['name'] == k and f['type'] == 'Constant' for f in ap['functions']), 'NOT_FOUND') need(bool(s), 'INVALID_ARGUMENT') return s def _mmanage(host, a): ap, prof = host.ap, host.AP_PROFILE m = method(ap, a['method']) need(m is not None, 'NOT_FOUND') act = a['action'] i = ap['methods'].index(m) if act == 'copy': need(len(ap['methods']) < prof['max_methods'], 'NOT_ALLOWED') n = 1 while method(ap, f'{m["name"]} ({n})'): n += 1 name = a.get('name') or f'{m["name"]} ({n})' need(method(ap, name) is None, 'IN_USE') new = copy.deepcopy(m) new.update(name=name, protected=False, visible=True) ap['methods'].append(new) # gsf p.23: the copy is saved at the last position audit(host, f'Method {name} created as a copy of {m["name"]}') return dict(method=name) if act in ('rename', 'delete'): need(m['name'] != ap['active'], 'IN_USE') # gsf p.23: not the current method need(not m['protected'], 'NOT_ALLOWED') if act == 'rename': need('name' in a and method(ap, a['name']) is None, 'IN_USE') old = m['name'] m['name'] = a['name'] for e in ap['sample_list']: if e['method'] == old: e['method'] = a['name'] elif act == 'delete': need(len(ap['methods']) > 1, 'NOT_ALLOWED') need(not any(e['method'] == m['name'] and e['status'] == 'pending' for e in ap['sample_list']), 'IN_USE') ap['methods'].remove(m) elif act in ('move_up', 'move_down'): j = i - 1 if act == 'move_up' else i + 1 need(0 <= j < len(ap['methods']), 'NOT_ALLOWED') ap['methods'][i], ap['methods'][j] = ap['methods'][j], ap['methods'][i] elif act in ('show_all', 'hide_all'): # gsf p.23: all methods except the current one for x in ap['methods']: if x['name'] != ap['active']: x['visible'] = act == 'show_all' else: need('visible' in a, 'INVALID_ARGUMENT') need(a['visible'] or m['name'] != ap['active'], 'IN_USE') m['visible'] = a['visible'] audit(host, f'Method {m["name"]}: {act}') return dict(method=m['name']) def _mode_keys(profile): """Method / quick keys of the DMA M modes RM (dma p.36-37) and TTS (dma p.38), only for instruments that have them.""" out = {} if 'RM' in profile['modes']: out.update(rm_count=num('1', 2, 5, integer=True), rm_dev=nullable(num('1', 0, 1)), rm_save={'type': 'string', 'enum': list(RM_SAVE)}) if 'TTS' in profile['modes']: out.update(tts_temps={'type': 'array', 'items': num('°C', profile['t_min_c'], profile['t_max_c']), 'maxItems': 30}) return out def quick_schema(profile): props = dict(sample_name={'type': 'string', 'maxLength': 50}, type={'type': 'string', 'enum': [k for k in MEASUREMENT_TYPES if k in profile['modes']]}, mm_count=num('1', 2, 10, integer=True), mf_count=num('1', 2, profile.get('mf_max', 5), integer=True), ts_start=num('°C', profile['t_min_c'], profile['t_max_c']), ts_step=num('°C', 0.01, profile['t_max_c'] - profile['t_min_c']), ts_end=num('°C', profile['t_min_c'], profile['t_max_c']), check=nullable(NAME), field1={'type': 'string', 'maxLength': 30}, field2={'type': 'string', 'maxLength': 30}, field3={'type': 'string', 'maxLength': 30}, **_mode_keys(profile)) props.update({f['key']: field_schema(f) for f in profile['method_fields'] if f['key'] in profile['quick_fields']}) return {'type': 'object', 'properties': props, 'additionalProperties': False, 'minProperties': 1} def _quick(host, a): ap, prof = host.ap, host.AP_PROFILE check(quick_schema(prof), a['settings']) q = dict(ap['quick'], **copy.deepcopy(a['settings'])) if q['type'] == 'C': need(q['check'] is not None and any(c['name'] == q['check'] for c in ap['checks']), 'NOT_FOUND') need(abs(q['ts_end'] - q['ts_start']) / q['ts_step'] <= 200 + 1e-9, 'INVALID_ARGUMENT') ap['quick'] = q prof['apply_method'](host, method(ap), q) audit(host, f'Quick settings changed: {", ".join(sorted(a["settings"]))}') return dict(settings=copy.deepcopy(a['settings'])) def _sample_list(host, a): ap = host.ap act, sl = a['action'], ap['sample_list'] if act in ('add', 'update'): need('entry' in a, 'INVALID_ARGUMENT') e = a['entry'] need(e.get('type', 'S') in host.AP_PROFILE['modes'], 'INVALID_ARGUMENT') m = method(ap, e['method']) need(m is not None and m['visible'], 'NOT_FOUND') new = dict(name=e['name'], method=e['method'], type=e.get('type', 'S'), field1=e.get('field1', ''), field2=e.get('field2', ''), field3=e.get('field3', ''), status='pending', record=None) if act == 'add': sl.append(new) if len(sl) > 200: # abm p.82: the 201st entry overwrites the oldest del sl[0] else: need(a.get('index') is not None and 0 <= a['index'] < len(sl), 'NOT_FOUND') need(sl[a['index']]['status'] == 'pending', 'NOT_ALLOWED') # measured samples cannot be edited (abm p.83) sl[a['index']] = new _list_warnings(host) elif act == 'delete': need(a.get('index') is not None and 0 <= a['index'] < len(sl), 'NOT_FOUND') need(sl[a['index']]['status'] == 'pending', 'NOT_ALLOWED') del sl[a['index']] elif act == 'clear': ap['sample_list'] = [] ap['messages'] = [] # abm p.25, p.83: the message list is cleared with the sample list elif act == 'save': need(a.get('template') is not None, 'INVALID_ARGUMENT') t = ap['templates'][a['template']] t['entries'] = [dict(e, status='pending', record=None) for e in sl] if a.get('name'): t['name'] = a['name'] elif act == 'load': need(a.get('template') is not None, 'INVALID_ARGUMENT') ap['sample_list'] = copy.deepcopy(ap['templates'][a['template']]['entries']) else: need(a.get('template') is not None and a.get('name'), 'INVALID_ARGUMENT') ap['templates'][a['template']]['name'] = a['name'] audit(host, f'Sample list: {act}') return dict(count=len(ap['sample_list'])) def _list_warnings(host): ap = host.ap s = ap['settings'] if s['samples.warn_no_name'] and any(not e['name'] for e in ap['sample_list'] if e['status'] == 'pending'): add_message(host, 'warning', 'The sample list contains a sample without a name.') if s['samples.warn_temperatures']: temps = {host.AP_PROFILE['method_temperature'](method(ap, e['method'])) for e in ap['sample_list'] if e['status'] == 'pending'} if len(temps) > 1: add_message(host, 'warning', 'The sample list contains methods with different measuring temperatures.') def _monitor(host, a): ap = host.ap ap['monitor'] = a['active'] if a['active']: ap['frozen'] = ap['frozen_rec'] = None # abm p.85: unfreeze the result return dict(active=a['active']) COMPARATORS_OF = {'Print/Export Status': ('printed/exported', 'not printed/exported'), 'Date Range': ('equals', 'not equal'), 'Measuring Value': ('larger than', 'smaller than', 'equals', 'not equal')} def _filter(host, a): lst = host.ap['filters'][a['view']] if a['action'] == 'add': c = a.get('criterion') need(c is not None and len(lst) < 8, 'INVALID_ARGUMENT') crit, comp = c['criterion'], c['comparator'] need(comp in COMPARATORS_OF.get(crit, ('equals', 'not equal', 'containing', 'not containing')), 'INVALID_ARGUMENT') need(crit != 'Date Range' or c.get('value') in DATE_RANGES, 'INVALID_ARGUMENT') lst.append(dict(criterion=crit, comparator=comp, value=c.get('value', ''))) elif a['action'] == 'delete': need(a.get('index') is not None and a['index'] < len(lst), 'NOT_FOUND') del lst[a['index']] else: lst.clear() return dict(count=len(filtered(host, a['view']))) def _delete(host, a): ap = host.ap key = 'data' if a['kind'] == 'measured' else 'check_data' if ap['settings']['security.increased']: # abm Table 9.2 p.55: only exported data can be deleted need(False, 'NOT_EXPORTED') if a['id'] is not None: rec = next((r for r in ap[key] if r['id'] == a['id']), None) need(rec is not None, 'NOT_FOUND') need(not any(e['record'] == rec['id'] for e in ap['sample_list']), 'IN_USE') # gsf p.27: samples still in the sample list gone = [rec] else: gone = filtered(host, 'delete') if key == 'data' else list(ap[key]) gone = [r for r in gone if not any(e['record'] == r['id'] for e in ap['sample_list'])] if key == 'data' else gone ids = {r['id'] for r in gone} ap[key] = [r for r in ap[key] if r['id'] not in ids] if key == 'data' and ap['frozen'] in ids: ap['frozen'] = ap['frozen_rec'] = None audit(host, f'{len(gone)} {a["kind"]} data deleted ({", ".join(r.get("uid", str(r["id"])) for r in gone[:10])})') return dict(deleted=len(gone)) def _sign(host, a): ap = host.ap s = ap['settings'] need(s['security.esign'], 'NOT_ALLOWED') rec = next((r for r in ap['data'] if r['id'] == a['id']), None) need(rec is not None, 'NOT_FOUND') u = user_record(ap, ap['user']) role = u['role'] need(role != 'None', 'PERMISSION_DENIED') if s['security.esign_password']: need(_pw_equal(host, u['password'], a.get('password', '')), 'WRONG_PASSWORD') roles = ['submitter', 'reviewer', 'approver'] if s['security.esign_levels'] == '3 roles' else ['submitter', 'approver'] mine = role.lower() need(mine in roles, 'NOT_ALLOWED') if mine == 'submitter': need(rec['user'] == u['name'], 'NOT_ALLOWED') # abm p.60: only the user who measured signs as submitter need(rec['signatures'][mine] is None, 'NOT_ALLOWED') # a signature cannot be changed k = roles.index(mine) if k and any(rec['signatures'][r] is None for r in roles[:k]): need(s['security.esign_substitute'], 'NOT_ALLOWED') for r in roles[:k + 1]: if rec['signatures'][r] is None: rec['signatures'][r] = dict(positive=a['positive'], user=u['name'], time=device_iso(host)) if a.get('comment'): rec['comments'].append(dict(user=u['name'], text=a['comment'])) audit(host, f'Sample {rec["uid"]} signed {"positive" if a["positive"] else "negative"} as {role}') return dict(signatures=copy.deepcopy(rec['signatures'])) def _audit_delete(host, a): ap = host.ap n = sum(1 for e in ap['audit'] if e['exported']) ap['audit'] = [e for e in ap['audit'] if not e['exported']] # abm p.57: entries not yet exported cannot be deleted return dict(deleted=n) def _lists(host, a): ap = host.ap name, act = a['list'], a['action'] lst = ap[name] idx = a.get('index') if act in ('move_up', 'move_down', 'delete'): need(idx is not None and 0 <= idx < len(lst), 'NOT_FOUND') if act == 'delete': need(not (name in ('printers', 'reports') and lst[idx].get('default')), 'NOT_ALLOWED') # the default printer / report cannot be deleted del lst[idx] elif act in ('move_up', 'move_down'): j = idx - 1 if act == 'move_up' else idx + 1 need(0 <= j < len(lst), 'NOT_ALLOWED') lst[idx], lst[j] = lst[j], lst[idx] else: need('item' in a, 'INVALID_ARGUMENT') it = a['item'] if name == 'printers': check(obj(dict(name=NAME, type={'type': 'string', 'enum': list(PRINTER_TYPES)}, default=BOOL, format={'type': 'string', 'enum': ['A4', 'Letter']}, port={'type': 'string', 'enum': ['COM1', 'USB', 'Network']}, color=BOOL, ip={'type': 'string', 'maxLength': 15}), optional=('format', 'port', 'color', 'ip')), it) need(idx is not None or len(lst) < 5, 'NOT_ALLOWED') # up to 5 printers (abm p.39) elif name == 'extrapolation': check(obj(dict(value=num('1', -100, 300), unit={'type': 'string', 'enum': ['°C', '°F']})), it) need(idx is not None or len(lst) < 10, 'NOT_ALLOWED') elif name == 'shares': check(obj(dict(name=NAME, path={'type': 'string', 'maxLength': 64}, user={'type': 'string', 'maxLength': 30}, password={'type': 'string', 'maxLength': 30}), optional=('password',)), it) need(idx is not None or len(lst) < 10, 'NOT_ALLOWED') elif name == 'reports': check(obj(dict(name=NAME, type={'type': 'string', 'enum': list(REPORT_TYPES)}, default=BOOL, gxp=BOOL, orientation={'type': 'string', 'enum': ['Portrait', 'Landscape']}, printed_by=BOOL), optional=('gxp', 'orientation', 'printed_by')), it) need(idx is not None or len(lst) < 10, 'NOT_ALLOWED') # up to 10 reports (abm p.43) else: check(obj(dict(q={'type': 'string', 'minLength': 1, 'maxLength': 60})), it) need(_quantity_ok(host.AP_PROFILE, ap, it['q']), 'INVALID_ARGUMENT') it = it['q'] if name not in ('browser', 'extrapolation'): clash = [i for i, x in enumerate(lst) if x['name'] == it['name']] need(not clash or clash == [idx], 'IN_USE') it = dict(it) if it.get('default'): for x in lst: x['default'] = False if idx is None: lst.append(it) else: need(0 <= idx <= len(lst), 'NOT_FOUND') if idx == len(lst): lst.append(it) else: if name != 'browser' and lst[idx].get('default') and not it.get('default'): it['default'] = True # one default stays (abm p.39) lst[idx] = it audit(host, f'{name}: {act}') return dict(count=len(lst)) def _fsave(host, a): ap, prof = host.ap, host.AP_PROFILE f = copy.deepcopy(a['function']) t = f['type'] inputs = f.get('inputs', []) for q in inputs: need(_quantity_ok(prof, ap, q) and prof['quantities'].get(q, {}).get('kind') != 'text', 'INVALID_ARGUMENT') need(len(inputs) == {'Constant': 0, 'Linear Function': 1, 'Polynomial (1D)': 1, 'Polynomial (2D)': 2, 'Table': 1}.get(t, len(inputs)), 'INVALID_ARGUMENT') if t == 'Constant': need('value' in f, 'INVALID_ARGUMENT') elif t == 'Linear Function': need('offset' in f and 'factor' in f, 'INVALID_ARGUMENT') elif t.startswith('Polynomial'): f['coefficients'] = (list(f.get('coefficients', [])) + [0.0] * 10)[:7 if t == 'Polynomial (1D)' else 10] elif t == 'Table': f['table'] = [list(p) for p in f.get('table', [])] need(len({p[0] for p in f['table']}) == len(f['table']), 'INVALID_ARGUMENT') # pairs may follow row by row (functions.table_edit) else: need(1 <= len(inputs) <= 2 and len(f.get('variables', [])) == len(inputs) and f.get('formula'), 'INVALID_ARGUMENT') need(all(re.match(r'^[A-Za-z_]\w*$', v) for v in f['variables']), 'INVALID_ARGUMENT') need(formula_ok(f['formula'], set(f['variables'])), 'INVALID_ARGUMENT') f.setdefault('quantity', ''), f.setdefault('unit', ''), f.setdefault('comment', ''), f.setdefault('protected', False) f['owner'] = ap['user'] orig = a.get('original') names = [x['name'] for x in ap['functions']] if orig is None: need(f['name'] not in names, 'IN_USE') need(len(ap['functions']) < prof.get('max_functions', 80), 'NOT_ALLOWED') ap['functions'].append(f) else: need(orig in names, 'NOT_FOUND') old = ap['functions'][names.index(orig)] need(not old['protected'] or old['owner'] == ap['user'], 'NOT_ALLOWED') # gsf p.35: protected against changes by other users if t == 'Table' and 'table' not in a['function'] and old['type'] == 'Table': f['table'] = copy.deepcopy(old['table']) # the pairs are edited row by row need(f['name'] == orig or f['name'] not in names, 'IN_USE') ap['functions'][names.index(orig)] = f if f['name'] != orig: _rename_quantity(ap, 'fn:' + orig, 'fn:' + f['name']) audit(host, f'User function {f["name"]} saved') return dict(name=f['name']) def _rename_quantity(ap, old, new): for m in ap['methods']: for k in ('fields', 'output', 'limits'): for x in m[k]: if x['q'] == old: x['q'] = new ap['browser'] = [new if q == old else q for q in ap['browser']] def _fdelete(host, a): ap = host.ap f = next((x for x in ap['functions'] if x['name'] == a['name']), None) need(f is not None, 'NOT_FOUND') q = 'fn:' + f['name'] need(not any(lim['q'] == q for m in ap['methods'] for lim in m['limits']), 'IN_USE') # abm p.136: not when used as a limit ap['functions'].remove(f) for m in ap['methods']: m['fields'] = [x if x['q'] != q else dict(q='', unit='', digits=0) for x in m['fields']] m['output'] = [x for x in m['output'] if x['q'] != q] ap['browser'] = [x for x in ap['browser'] if x != q] audit(host, f'User function {f["name"]} deleted') return dict(name=f['name']) def _calc(host, a): ap, prof = host.ap, host.AP_PROFILE f = next((x for x in ap['functions'] if x['name'] == a['function']), None) need(f is not None, 'NOT_FOUND') need(len(a['inputs']) == len(f.get('inputs', [])), 'INVALID_ARGUMENT') v = function_value(f, dict(zip(f.get('inputs', []), a['inputs'])), method(ap)['constants']) ap['calculator'] = dict(function=f['name'], inputs=list(a['inputs']), value=v) del prof return dict(value=v) def _calc_group(host, a): ap = host.ap vals = {q: float(v) for q, v in a['inputs'].items()} out = {f['name']: function_value(f, vals, method(ap)['constants']) for f in ap['functions']} ap['calculator'] = dict(function=None, inputs=dict(vals), values=out) return dict(values=out) def _table_edit(host, a): ap = host.ap f = next((x for x in ap['functions'] if x['name'] == a['name']), None) need(f is not None and f['type'] == 'Table', 'NOT_FOUND') need(not f['protected'] or f['owner'] == ap['user'], 'NOT_ALLOWED') if a['action'] == 'add': need('x' in a and 'y' in a and len(f['table']) < 1000, 'INVALID_ARGUMENT') need(all(p[0] != a['x'] for p in f['table']), 'IN_USE') f['table'] = sorted(f['table'] + [[a['x'], a['y']]]) else: need(a.get('index') is not None and a['index'] < len(f['table']), 'NOT_FOUND') del f['table'][a['index']] audit(host, f'User function {f["name"]}: table {a["action"]}') return dict(pairs=len(f['table'])) def _checks(host, a): ap, prof = host.ap, host.AP_PROFILE c = a['check'] names = [x['name'] for x in ap['checks']] if a['action'] == 'delete': need(c.get('name') in names, 'NOT_FOUND') x = ap['checks'][names.index(c['name'])] need(not x.get('factory'), 'NOT_ALLOWED') # the predefined water check stays (abm p.75) need(not any(m['check'] == x['name'] for m in ap['methods']), 'IN_USE') ap['checks'].remove(x) return dict(name=x['name']) check(prof['check_schema'], c) c = dict(c, tolerances=[t for t in c.get('tolerances', []) if t.get('q')]) # rows without a quantity are empty rows of the wizard for t in c['tolerances']: need(t.get('lower') is not None and t.get('upper') is not None, 'INVALID_ARGUMENT') orig = a.get('original') if c['kind'] == 'Custom Check': need(method(ap, c.get('method')) is not None, 'NOT_FOUND') if c['kind'] == 'Reference Standard Check': need(any(s['name'] == c.get('standard') for s in ap['standards']), 'NOT_FOUND') for t in c.get('tolerances', []): need(_quantity_ok(prof, ap, t['q']) and t['lower'] < t['upper'], 'INVALID_ARGUMENT') new = dict(prof['check_default'], **copy.deepcopy(c)) if orig is None: need(c['name'] not in names, 'IN_USE') new['last'] = None ap['checks'].append(new) else: need(orig in names, 'NOT_FOUND') old = ap['checks'][names.index(orig)] need(c['name'] == orig or c['name'] not in names, 'IN_USE') new['last'], new['factory'] = old.get('last'), old.get('factory', False) if new['factory']: need(new['kind'] == old['kind'], 'NOT_ALLOWED') ap['checks'][names.index(orig)] = new for m in ap['methods']: if m['check'] == orig: m['check'] = c['name'] audit(host, f'Check {c["name"]} saved') return dict(name=c['name']) def _standards(host, a): ap, prof = host.ap, host.AP_PROFILE s = a['standard'] names = [x['name'] for x in ap['standards']] if a['action'] == 'delete': need(s.get('name') in names, 'NOT_FOUND') x = ap['standards'][names.index(s['name'])] need(not any(c.get('standard') == x['name'] for c in ap['checks']), 'IN_USE') ap['standards'].remove(x) return dict(name=x['name']) check(prof['standard_schema'], s) orig = a.get('original') if orig is None: need(s['name'] not in names, 'IN_USE') ap['standards'].append(copy.deepcopy(s)) else: need(orig in names, 'NOT_FOUND') need(s['name'] == orig or s['name'] not in names, 'IN_USE') ap['standards'][names.index(orig)] = copy.deepcopy(s) for c in ap['checks']: if c.get('standard') == orig: c['standard'] = s['name'] audit(host, f'Reference standard {s["name"]} saved') return dict(name=s['name']) def _touch_cal(host, a): pts = a['points'] targets = host.AP_PROFILE['touch_targets'] # the four crosses shown by the calibration page need(all(abs(p[0] - t[0]) <= 40 and abs(p[1] - t[1]) <= 40 for p, t in zip(pts, targets)), 'NOT_ALLOWED') # a tap far off the cross is refused host.ap['touch_cal'] = dict(time=device_iso(host), points=copy.deepcopy(pts)) return dict(calibrated=True) def _firmware(host, a): host.ap['firmware_checked'] = device_iso(host) # abm p.105 'Internal': modules already at the supported version return dict(up_to_date=True) def _start(host, a): return run_start(host, dict(kind='sample')) def _continue(host, a): return run_continue(host) def _check_start(host, a): return run_start(host, dict(kind='check', check=a['check'])) _HANDLERS = {'settings.configure': _settings, 'clock.set': _clock, 'user.logon': _logon, 'user.logoff': _logoff, 'users.save': _users_save, 'users.delete': _users_delete, 'users.set_password': _users_password, 'groups.manage': _groups, 'messages.acknowledge': _ack, 'favorites.configure': _favorites, 'methods.select': _select, 'methods.configure': _mconfigure, 'methods.manage': _mmanage, 'quick.configure': _quick, 'sample_list.edit': _sample_list, 'measurement.start': _start, 'measurement.continue': _continue, 'monitor.set': _monitor, 'data.filter': _filter, 'data.delete': _delete, 'data.sign': _sign, 'audit.delete': _audit_delete, 'lists.edit': _lists, 'functions.save': _fsave, 'functions.delete': _fdelete, 'calculator.evaluate': _calc, 'checks.manage': _checks, 'standards.manage': _standards, 'calculator.group': _calc_group, 'functions.table_edit': _table_edit, 'check.start': _check_start, 'touchscreen.calibrate': _touch_cal, 'firmware.check': _firmware} # ---------------------------------------------------------------- measurement bookkeeping shared by the instruments def sample_name_for(host, base, number): """Automatic sample name additions after the measurement (abm p.45, p.84): prefix / postfix text plus a data field.""" ap = host.ap s = ap['settings'] def part(field): if field == 'Date and Time': return device_dt(host).strftime('%Y-%m-%d %H:%M') if field == 'User Name': return ap['user'] or '' if field == 'Sample Number': return str(number) if field == 'Method': return ap['active'] return '' name = ''.join(x for x in (s['samples.prefix'], part(s['samples.prefix_field']), base, part(s['samples.postfix_field']), s['samples.postfix'])) return name[:50] or f'Sample {number}' def limits_ok(m, values): bad = [] for lim in (m['limits'] if m else []): v = values.get(lim['q']) if v is None: continue if (lim['lower'] is not None and v < lim['lower']) or (lim['upper'] is not None and v > lim['upper']): bad.append(lim['q']) return bad def finish_measurement(host, run, readings): """Store the readings of a run (one record per reading; MM / MF also an average record), apply the method limits, naming, beep and automatic printout (abm p.77-78, p.86; gsf p.22).""" ap, prof = host.ap, host.AP_PROFILE m = method(ap, run['method']) number = ap['sample_no'] name = sample_name_for(host, run['sample_name'], number) recs = [] rdev = None if run['type'] == 'RM' and run.get('rm_converged'): # dma p.36-37: save all, the valid two or the final one only xs = [r['values'].get(prof['main_quantity']) for r in readings[-2:]] rdev = round(abs(xs[1] - xs[0]), 7) if len(xs) == 2 and None not in xs else None # repeat deviation of the two agreeing results keep = {'all': readings, 'valid two only': readings[-2:], 'final one only': readings[-1:]}[run.get('rm_save', 'all')] readings = keep multi = run['type'] in ('MM', 'MF', 'RM') and len(readings) > 1 kind = 'scan' if run['type'] in ('TS', 'TTS') else 'measurement' for k, r in enumerate(readings): vals = record_values(prof, ap, r['values'], m) if rdev is not None and not multi and 'repeat_dev' in vals: vals['repeat_dev'] = rdev bad = limits_ok(m, vals) rec = store_record(host, dict(time=device_iso(host), sample_name=name + (f' #{k + 1}' if multi or kind == 'scan' else ''), method=run['method'], type=run['type'], user=ap['user'] or '-', values=vals, condition=r['condition'], error_state='Error' if r['condition'] != 'valid' or bad else 'No Error', limits_failed=bad, kind=kind, sub=multi, sample_no=number, fields=[run.get('field1', ''), run.get('field2', ''), run.get('field3', '')])) if rec is None: break recs.append(rec) if bad: add_message(host, 'warning', f'{name}: result outside the limits ({", ".join(quantity_label(prof, ap, q) for q in bad)}).') if r['condition'] != 'valid': add_message(host, r.get('level', 'error'), f'{name}: {r["condition"]}.') if r.get('camera_image'): rec['camera_image'] = True if run['type'] == 'RM' and not run.get('rm_converged'): add_message(host, 'warning', f'{name}: the deviation of the repeated measurements is too high.') if multi and recs: avg = {} for q in recs[0]['values']: xs = [x['values'][q] for x in recs if isinstance(x['values'].get(q), (int, float)) and not isinstance(x['values'].get(q), bool)] avg[q] = sum(xs) / len(xs) if xs and len(xs) == len(recs) else recs[-1]['values'][q] if rdev is not None and 'repeat_dev' in avg: avg['repeat_dev'] = rdev bad = limits_ok(m, avg) ok = all(x['condition'] == 'valid' for x in recs) rec = store_record(host, dict(time=device_iso(host), sample_name=name, method=run['method'], type=run['type'], user=ap['user'] or '-', values=avg, condition='valid' if ok else recs[-1]['condition'], error_state='Error' if bad or not ok else 'No Error', limits_failed=bad, kind='measurement', sub=False, avg=True, sample_no=number, fields=[run.get('field1', ''), run.get('field2', ''), run.get('field3', '')])) if rec: recs.append(rec) ap['sample_no'] += 1 if recs: ap['frozen'] = recs[-1]['id'] ap['frozen_rec'] = copy.deepcopy(recs[-1]) ap['monitor'] = False if ap['settings']['control.beep_measurement']: ap['beeps'] += 1 if ap['settings']['printout.auto'] and recs: if not ap['printers']: add_message(host, 'warning', 'Automatic printout: no printer available.') else: ap['auto_printouts'] += 1 add_message(host, 'warning', 'Automatic printout: the printer is not connected.') if run.get('list_index') is not None and run['list_index'] < len(ap['sample_list']): e = ap['sample_list'][run['list_index']] e['status'] = 'measured' if recs and all(r['error_state'] == 'No Error' for r in recs) else 'error' e['record'] = recs[-1]['id'] if recs else None audit(host, f'Measurement of {name} ({run["method"]}) finished: {len(recs)} result(s)') return recs def finish_check(host, run, reading): """A check: compare the measured value with the reference / tolerances and store the check data (abm p.63-65).""" ap, prof = host.ap, host.AP_PROFILE c = next((x for x in ap['checks'] if x['name'] == run['check']), None) if c is None: return None res = prof['evaluate_check'](host, c, reading) rec = dict(id=ap['next_check'], time=device_iso(host), check=c['name'], kind=c['kind'], method=run['method'], user=ap['user'] or '-', temperature=reading['values'].get(prof['temperature_quantity']), condition=reading['condition'], **res) ap['next_check'] += 1 if len(ap['check_data']) >= prof.get('check_capacity', 100): if ap['settings']['memory.auto_delete_checks']: del ap['check_data'][:10] else: add_message(host, 'error', 'Check data memory is full.') return None ap['check_data'].append(rec) c['last'] = dict(time=rec['time'], result=rec['result'], user=rec['user']) if rec['result'] != 'passed': add_message(host, 'warning', f'Check "{c["name"]}" not passed.') audit(host, f'Check {c["name"]}: {rec["result"]}') if ap['settings']['control.beep_measurement']: ap['beeps'] += 1 return rec def check_due(host, c): """Days until the next execution of a check with a reminder (None without a reminder); negative when overdue.""" if not c.get('reminder'): return None if not c.get('last'): return -1 last = datetime.datetime.fromisoformat(c['last']['time']) return c['interval_days'] - (device_dt(host) - last).total_seconds() / 86400.0 # ---------------------------------------------------------------- measurement runs (abm p.75-76, p.86; Appendix C p.133) # A run: temperature equilibration (with temperature control) -> hold time -> the instrument's reading (its stability time) -> next reading # (MM), next fill (MF, the operator exchanges the sample and confirms), next temperature (TS) or the end; the timeout aborts a reading cycle # that has not finished. The physics stays in the runtime: profile hooks set_temperature / temperature_ok / begin_reading / resume / reading. def run_start(host, spec): """measurement.start / check.start / adjustment.start: build the run from the quick settings, the sample list entry, the check or the adjustment standards, check the instrument (profile 'precheck') and start the first cycle.""" ap, prof = host.ap, host.AP_PROFILE need(ap['run'] is None, 'BUSY') need(len(ap['data']) < prof['memory_capacity'] or ap['settings']['memory.auto_delete'] or spec['kind'] == 'adjust', 'MEMORY_FULL') q = ap['quick'] m = method(ap) run = dict(kind=spec['kind'], method=m['name'], type=q['type'], sample_name=q['sample_name'], field1=q['field1'], field2=q['field2'], field3=q['field3'], list_index=None, check=None, k=0, readings=[], stage='equilibrating', cycle_t=host.time_s, stage_t=host.time_s, hold_left=0.0, ti=0, prompt=None, adjust=spec.get('adjust')) if spec['kind'] == 'sample' and ap['settings']['samples.mode'] == 'Sample List': idx = next((i for i, e in enumerate(ap['sample_list']) if e['status'] == 'pending'), None) need(idx is not None, 'NOT_FOUND') # nothing left to measure in the sample list (assumption) e = ap['sample_list'][idx] m = method(ap, e['method']) need(m is not None, 'NOT_FOUND') q = dict(quick_from_method(prof, m), sample_name=e['name'], type=e['type'], field1=e['field1'], field2=e['field2'], field3=e['field3']) run.update(method=m['name'], type=e['type'], sample_name=e['name'], field1=e['field1'], field2=e['field2'], field3=e['field3'], list_index=idx) if spec['kind'] == 'sample' and run['type'] == 'C': spec = dict(kind='check', check=q['check'] or m['check']) run['kind'] = 'check' if spec['kind'] == 'check': c = next((x for x in ap['checks'] if x['name'] == spec.get('check')), None) need(c is not None, 'NOT_FOUND') run.update(check=c['name'], type='C', sample_name=c['name']) if c['kind'] == 'Custom Check': m = method(ap, c['method']) need(m is not None, 'NOT_FOUND') run['method'] = m['name'] q = quick_from_method(prof, m) s = ap['settings'] if spec['kind'] == 'sample': need(not s['samples.mandatory_name'] or run['sample_name'].strip(), 'MANDATORY_FIELD') for i in (1, 2, 3): need(not (s[f'samples.field{i}'] and s[f'samples.mandatory_field{i}']) or run[f'field{i}'].strip(), 'MANDATORY_FIELD') for c in ap['checks']: # gsf p.24-25: prohibit measurements after the check interval expired due = check_due(host, c) need(not (c.get('prohibit') and due is not None and due < 0), 'CHECK_OVERDUE') run['params'] = prof['run_params'](host, m, q, run) if run['type'] == 'TS' and run['kind'] == 'sample': st, sp, en = q['ts_start'], q['ts_step'], q['ts_end'] n = int(math.floor(abs(en - st) / sp + 1e-9)) + 1 run['temps'] = [round(st + math.copysign(sp, en - st) * i, 6) for i in range(n)] elif run['type'] == 'TTS' and run['kind'] == 'sample': need(bool(q.get('tts_temps')), 'NOT_FOUND') # dma p.38: the temperature table of the method run['temps'] = list(q['tts_temps']) else: run['temps'] = [run['params']['temp_c']] counts = dict(MM=q['mm_count'], MF=q['mf_count'], RM=q.get('rm_count', 3)) run['n'] = counts.get(run['type'], len(run['temps'])) if run['kind'] == 'sample' \ else len(run['adjust']['standards']) if run['kind'] == 'adjust' and run['adjust'].get('standards') else 1 run.update(rm_save=q.get('rm_save', 'all'), rm_dev=q.get('rm_dev')) pre = prof.get('pre_run', lambda h, r: None)(host, run) # e.g. the auto air check before a measurement (dma p.24) if pre is None: prof['precheck'](host, run) ap['run'] = run out = prof['begin'](host, run) run['op'] = host.operation_id # the run's operation (owner_guard), kept while it waits for a fill if pre is not None: run['pre'] = pre run.update(stage='await_fill', prompt=prof['pre_prompt'](host, run)) host.phase = 'idle' if host.phase == 'running' else host.phase return out if prof.get('first_fill', lambda h, r: False)(host, run): # the first standard is filled after the start (dma p.30) run.update(stage='await_fill', prompt=prof['fill_prompt'](host, run)) host.phase = 'idle' if host.phase == 'running' else host.phase return out _cycle(host, run) return out def _cycle(host, run): """Start a reading cycle: temperature of this cycle, then equilibration (only with temperature control) or straight to the hold time.""" prof = host.AP_PROFILE t = run['temps'][min(run['ti'], len(run['temps']) - 1)] if run['kind'] == 'adjust' and run['adjust'].get('standards'): t = run['adjust']['standards'][min(run['k'], len(run['adjust']['standards']) - 1)].get('temperature_c', t) run['temp_c'] = t run['cycle_t'] = run['stage_t'] = host.time_s if run['params']['control']: prof['set_temperature'](host, t) run['stage'] = 'equilibrating' else: run.update(stage='hold', hold_left=run['params']['hold_s']) def run_tick(host, h): """Advance a run by one physics substep of h seconds (called by the runtime's step after the physics of that substep).""" ap, prof = host.ap, host.AP_PROFILE run = ap['run'] if run is None or run['stage'] == 'await_fill': return if host.phase != 'running': # stopped () or switched off ap['run'] = None return if run['stage'] == 'equilibrating': if prof['temperature_ok'](host, run['params']['tol_c']): run.update(stage='hold', hold_left=run['params']['hold_s'], stage_t=host.time_s, eq_t=host.time_s) if run['hold_left'] <= 1e-9: _reading(host, run) return elif run['stage'] == 'hold': run['hold_left'] -= h if run['hold_left'] <= 1e-9: _reading(host, run) return elif run['stage'] == 'empty': # no sample on the prism: the reading finds nothing run['empty_left'] -= h if run['empty_left'] <= 1e-9: host.phase = 'succeeded' # the reading ends as a physics reading would run_reading_done(host, prof['reading'](host, empty=True)) return timeout = run['params'].get('timeout_s') if timeout and run['params'].get('timeout_from') == 'equilibrium': # dma p.35: the timeout count starts at temperature equilibrium late = run.get('eq_t') is not None and host.time_s - run['eq_t'] >= timeout - 1e-9 and run['stage'] in ('hold', 'measuring', 'empty') else: late = timeout and host.time_s - run['cycle_t'] >= timeout - 1e-9 and run['stage'] in ('equilibrating', 'hold') if late: host.phase = 'cancelled' ap['run'] = None add_message(host, 'error', prof['timeout_text']) # abm p.76: aborted when not finished within the timeout audit(host, f'Measurement aborted: {prof["timeout_text"]}') def _reading(host, run): prof = host.AP_PROFILE run['stage_t'] = host.time_s if prof['begin_reading'](host, run['params']['stability_s']): run['stage'] = 'measuring' else: run.update(stage='empty', empty_left=run['params']['stability_s']) def run_reading_done(host, reading): """One reading finished (physics completion or an empty prism): next reading, next fill, next temperature, or the end of the run.""" ap, prof = host.ap, host.AP_PROFILE run = ap['run'] if run is None: # a measurement through acquisition.start: stored like an S measurement prof['direct_done'](host, reading) return if run.get('pre'): # the pre-run check: then the operator fills the sample ok = prof['pre_done'](host, run, reading) run['pre']['state'] = 'passed' if ok else 'failed' run.update(stage='await_fill', prompt=prof['pre_prompt'](host, run)) host.phase = 'idle' return run['readings'].append(dict(reading, temp_c=run['temp_c'])) run['k'] += 1 if run['kind'] == 'sample' and run['type'] == 'RM': # dma p.36-37: stop when two subsequent results agree q = prof['main_quantity'] xs = [r['values'].get(q) for r in run['readings'][-2:]] dev = run.get('rm_dev') if run.get('rm_dev') is not None else run['params'].get('rm_dev_default', 0.0) if len(xs) == 2 and None not in xs and abs(xs[1] - xs[0]) <= dev + 1e-12: run['rm_converged'] = True run['k'] = run['n'] if run['kind'] == 'sample' and run['type'] == 'MM' and run['k'] < run['n']: prof['resume'](host) _reading(host, run) # the same sample again (abm p.74) return if run['kind'] == 'sample' and run['type'] in ('TS', 'TTS') and run['k'] < run['n']: run['ti'] = run['k'] prof['resume'](host) _cycle(host, run) return if (run['kind'] == 'sample' and run['type'] in ('MF', 'RM') or run['kind'] == 'adjust') and run['k'] < run['n']: run.update(stage='await_fill', prompt=prof['fill_prompt'](host, run)) # the operator exchanges the sample and confirms return ap['run'] = None if run['kind'] == 'sample': finish_measurement(host, run, run['readings']) elif run['kind'] == 'check': finish_check(host, run, run['readings'][-1]) else: host._procedure_op = run.get('op', host.operation_id) # the adjustment result belongs to the run (owner_guard) prof['adjust_done'](host, run) def run_continue(host): ap, prof = host.ap, host.AP_PROFILE run = ap['run'] need(run is not None and run['stage'] == 'await_fill', 'NO_PROCEDURE') if run.get('pre') and run['pre']['state'] == 'passed': run['pre'] = None # the sample is filled now: the measurement proper starts if run.get('pre'): prof['pre_check_cell'](host, run) else: prof['precheck'](host, run) run['prompt'] = None prof['resume'](host) _cycle(host, run) return dict(phase=host.phase) def run_cancel(host): """ while a Multi Fill / adjustment waits for the next fill (the instrument is idle then).""" if host.ap['run'] is not None: host.ap['run'] = None return True return False # ---------------------------------------------------------------- clock-driven device behaviour (called from the runtime's step) def tick(host): ap = host.ap s = ap['settings'] if ap['user'] and s['security.auto_logoff'] and host.time_s - ap['last_input_s'] >= s['security.auto_logoff_min'] * 60.0 - 1e-9: audit(host, f'User {ap["user"]} logged off automatically') ap['user'] = auto_logon_user(ap) if not s['security.increased'] else None for c in ap['checks']: due = check_due(host, c) if due is not None and due < 0 and c.get('last'): add_message(host, 'warning', f'Check "{c["name"]}" is overdue.') def screen_off(host): """Screen saver: the display switches off after the set idle time (abm p.34); any touch or a measurement start wakes it.""" ap = host.ap s = ap['settings'] if not s['control.screen_saver'] or host.phase == 'running': return False return host.time_s - max(ap['last_input_s'], ap['boot_s']) >= s['control.screen_saver_min'] * 60.0 - 1e-9 # ---------------------------------------------------------------- front panel: host protocol of the engine and the panel.* commands def panel_engine(): try: from asset_runtime import _panel_ui as engine return engine except ImportError: # loaded from its file path import importlib.util import sys if '_chemsim_panel_ui' not in sys.modules: spec = importlib.util.spec_from_file_location('_chemsim_panel_ui', Path(__file__).with_name('_panel_ui.py')) sys.modules['_chemsim_panel_ui'] = importlib.util.module_from_spec(spec) spec.loader.exec_module(sys.modules['_chemsim_panel_ui']) return sys.modules['_chemsim_panel_ui'] def panel_caps(spec): """Panel capabilities in the runtimes' tuple form: (input, output, components, meaning, kind, visibility, example, effects).""" out = {} for k, d in panel_engine().capability_definitions(spec).items(): out[k] = (d['input_schema'], d['output_schema'], d['component_ids'], d['function_zh'], d['kind'], d['visibility'], d['example_arguments'], []) return out class PanelHost: """The engine's host protocol on top of a runtime: panel_read (agent slots plus host.* values), panel_invoke (the session's invoke path of the runtime, refusals as PanelRejected), panel_time. Built per gesture; the UI state stays in runtime.panel_state (a plain dict).""" def __init__(self, rt): self.rt = rt def panel_read(self): return self.rt.panel_read() def panel_invoke(self, cap, args): engine = panel_engine() try: sess = getattr(self.rt, '_panel_session', None) if sess is not None: # a gesture made through a session keeps that caller's access rules sess._guard(cap, args) return self.rt.invoke(cap, **args) except ActionRejected as exc: raise engine.PanelRejected(str(exc)) from None def panel_time(self): return self.rt.time_s def owner_guard(host, principal, role, cap, args): """Caller rule of the sessions (direct call or panel gesture alike): an agent may not stop or continue (next fill) another agent's run, nor apply / reject the adjustment result of another agent's adjustment run. The rear mains / power switch (power.set) is a hard switch: never refused, the instrument reacts as to a power loss (lead rule 2026-10-19).""" if role != 'agent': return def foreign(op): owner = host._owners.get(op) if op else None return owner is not None and owner != principal ops = [host.operation_id] if host.phase == 'running' else [] # a running operation, and a device run (also one waiting for a fill) if host.ap['run'] is not None: ops.append(host.ap['run'].get('op', host.operation_id)) run = any(foreign(op) for op in ops) result = (host.ap['procedure'] or {}).get('kind') == 'adjust_result' and foreign(getattr(host, '_procedure_op', None)) if (cap in ('acquisition.stop', 'measurement.continue') and run) or (cap == 'adjustment.decide' and result): raise ActionRejected('ACCESS_DENIED') def panel(rt): engine = panel_engine() p = engine.PanelUI(rt.PANEL_SPEC, PanelHost(rt), hooks=getattr(rt, 'PANEL_HOOKS', None)) # e.g. the DMA camera picture (drawn when shown) if rt.panel_state is not None: p.ui = rt.panel_state return p def panel_gesture(rt, kind, args): engine = panel_engine() schema = rt.AP_CAPS[f'panel.{kind}'][0] errs = engine.check_arguments(schema, args) need(not errs, 'INVALID_ARGUMENT') p = panel(rt) woke = kind == 'touch' and screen_off(rt) rt.ap['last_input_s'] = rt.time_s if woke: # abm p.34: a touch only switches the display on again rt.revision += 1 return dict(accepted=True) try: if kind == 'press': ok = p.press(args['input_id'], float(args.get('duration_s', 0.1)), tuple(args.get('held', ()))) elif kind == 'touch': to = (args['to_x'], args['to_y']) if 'to_x' in args and 'to_y' in args else None ok = p.touch(args['display_id'], args['x'], args['y'], float(args.get('duration_s', 0.1)), to) elif kind == 'turn': ok = p.turn(args['input_id'], args['detents']) else: ok = p.switch(args['input_id'], args['position'], tuple(args.get('held', ()))) except engine.PanelError: rt.panel_state = p.ui raise ActionRejected('INVALID_ARGUMENT') from None rt.panel_state = p.ui if rt.ap['settings'].get('control.beep_touch') and ok: rt.ap['beeps'] += 1 rt.revision += 1 return dict(accepted=bool(ok)) def panel_capture(rt, args): engine = panel_engine() need(not engine.check_arguments(rt.AP_CAPS['panel.capture'][0], args), 'INVALID_ARGUMENT') p = panel(rt) data, w, h = p.png_bytes(args['display_id']) rt.panel_state = p.ui sha = hashlib.sha256(data).hexdigest() d = Path(rt.panel_capture_dir) if getattr(rt, 'panel_capture_dir', None) else Path(tempfile.gettempdir()) / 'chemistry_sim_panel' / rt.instance_id d.mkdir(parents=True, exist_ok=True) path = d / f'{args["display_id"]}_{sha[:16]}.png' if not path.exists(): path.write_bytes(data) return dict(display_id=args['display_id'], time_s=rt.time_s, image=dict(path=str(path), format='png', width=w, height=h, sha256=sha)) def panel_frame(rt): p = panel(rt) f = p.frame() rt.panel_state = p.ui return dict(frame=f) def panel_invoke(rt, cap, args): if cap == 'panel.capture': return panel_capture(rt, args) if cap == 'panel.frame': need(not args, 'INVALID_ARGUMENT') return panel_frame(rt) return panel_gesture(rt, cap.split('.', 1)[1], args) # ---------------------------------------------------------------- slots and contract metadata of the device layer def device_slots(profile): """State slots of the device layer: (schema, unit, origin, visibility, components, write route).""" disp = profile['display_component'] lst = {'type': 'array', 'items': ANYOBJ} return { 'device.settings': (settings_schema(profile['settings'], 0), '1', 'setpoint', 'agent', [disp], None), 'device.datetime': ({'type': 'string', 'pattern': r'^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}$'}, '1', 'derived', 'agent', [disp], None), 'device.users': (ANYOBJ, '1', 'derived', 'agent', [disp], None), 'device.messages': (lst, '1', 'derived', 'agent', [disp], None), 'device.favorites': (lst, '1', 'setpoint', 'agent', [disp], None), 'device.lists': (ANYOBJ, '1', 'setpoint', 'agent', [disp], None), 'device.system': (ANYOBJ, '1', 'derived', 'agent', [disp], None), 'device.touch_calibration': (nullable(ANYOBJ), '1', 'derived', 'agent', [disp], None), 'methods.list': (lst, '1', 'setpoint', 'agent', [disp], None), 'methods.active': (STR, '1', 'setpoint', 'agent', [disp], ('methods.select', 'method')), 'sample.quick_settings': (ANYOBJ, '1', 'setpoint', 'agent', [disp], None), 'sample.list': (ANYOBJ, '1', 'setpoint', 'agent', [disp], None), 'data.measured': (lst, '1', 'derived', 'agent', [disp], None), 'data.filters': (ANYOBJ, '1', 'setpoint', 'agent', [disp], None), 'data.statistics': (lst, '1', 'derived', 'agent', [disp], None), 'data.checks': (lst, '1', 'derived', 'agent', [disp], None), 'data.adjustments': (lst, '1', 'derived', 'agent', [disp], None), 'data.audit_trail': (lst, '1', 'derived', 'agent', [disp], None), 'checks.list': (lst, '1', 'setpoint', 'agent', [disp], None), 'standards.list': (lst, '1', 'setpoint', 'agent', [disp], None), 'functions.list': (lst, '1', 'setpoint', 'agent', [disp], None), 'functions.calculator': (nullable(ANYOBJ), '1', 'derived', 'agent', [disp], None), 'run.state': (ANYOBJ, '1', 'derived', 'agent', [disp], None), 'display.readout': (ANYOBJ, '1', 'derived', 'agent', [disp], None), 'quantities.list': (lst, '1', 'derived', 'agent', [disp], None), 'display.tables': (ANYOBJ, '1', 'derived', 'agent', [disp], None), } SLOT_MEANING = { 'device.settings': '仪器设置（控制面板、打印、样品列表选项、数据存储、系统安全）', 'device.datetime': '仪器时钟（ISO本地时间）', 'device.users': '用户与用户组（无密码）、当前登录用户与权限、增强安全锁定', 'device.messages': '消息列表（警告/错误）与状态图标颜色', 'device.favorites': '收藏夹列表', 'device.lists': '打印机、报表与数据浏览列配置', 'device.system': '系统信息、重启计数、固件检查、蜂鸣与自动打印计数', 'device.touch_calibration': '最近一次触摸屏校准', 'methods.list': '方法列表与各方法设置', 'methods.active': '当前方法', 'sample.quick_settings': '下一次测量的快速设置（样品名、类型、参数）', 'sample.list': '样品列表与10个模板', 'data.measured': '数据存储中的测量结果', 'data.filters': '数据存储筛选条件', 'data.statistics': '按方法的统计（筛选后的测量结果）', 'data.checks': '核查数据', 'data.adjustments': '调整数据', 'data.audit_trail': '审计追踪', 'checks.list': '核查定义（含上次结果与到期）', 'standards.list': '参考标准', 'functions.list': '用户函数', 'functions.calculator': '计算器上次结果', 'run.state': '测量流程状态（阶段、进度、条件、MF等待装样、超时）', 'display.readout': '主屏显示：标题栏、输出字段文本、进度条、快捷区状态（实时/冻结、数值可见性）', 'quantities.list': '可选输出量（组、单位；含用户函数）', 'display.tables': '数据浏览、删除视图、详情、统计、核查/调整/审计列表的显示文本（仪器格式化后的单元格）'} def quantities_list(profile, ap): out = [dict(id=q, label=d['label'], group=d['group'], units=list(d.get('units') or ['']), kind=d.get('kind', 'number')) for q, d in profile['quantities'].items()] out += [dict(id='fn:' + f['name'], label=f['name'], group='User Functions', units=[f.get('unit') or ''], kind='number') for f in ap['functions']] return out + profile.get('extra_quantities', lambda a: [])(ap) def public_users(ap): me = user_record(ap, ap['user']) if ap['user'] else None return dict(current=ap['user'], group=me['group'] if me else None, rights=rights_of(ap), users=[{k: u[k] for k in ('name', 'group', 'active', 'auto_logon', 'role', 'sign_name', 'email', 'email_active')} | dict(has_password=bool(u['password'])) for u in ap['users']], groups=copy.deepcopy(ap['groups'])) def _cell(prof, ap, q, rec): d = prof['quantities'].get(q, {}) v = rec['values'].get(q) if d.get('kind') == 'text' or q in ('sample_name', 'method', 'user', 'date', 'time', 'unique_id', 'error_state'): v = {'sample_name': rec['sample_name'], 'method': rec['method'], 'user': rec['user'], 'unique_id': rec.get('uid', ''), 'error_state': rec['error_state'], 'date': rec['time'][:10], 'time': rec['time'][11:19]}.get(q, v) return '' if v is None else str(v) f = dict(q=q, unit=d.get('unit'), digits=d.get('digits', 4)) m = method(ap, rec['method']) for x in (m['output'] if m else []): if x['q'] == q: f = dict(x) return fmt_value(prof, f, v, ap) + (f' {f["unit"]}' if f.get('unit') and v is not None and d.get('kind') != 'text' else '') def _rows(host, recs, cols): ap, prof = host.ap, host.AP_PROFILE out = [] for i, r in enumerate(recs): m = method(ap, r['method']) qs = [x['q'] for x in (m['output'] if m and m['output'] else [])] or list(ap['browser']) det = [['Sample Name', r['sample_name']], ['Method', r['method']], ['Date / Time', r['time'].replace('T', ' ')], ['User', r['user']], ['Measurement Type', MEASUREMENT_TYPES.get(r['type'], r['type'])], ['Sample Error State', r['error_state']], ['Unique Sample ID', r['uid']]] det += [[quantity_label(prof, ap, q), _cell(prof, ap, q, r)] for q in qs if q not in ('sample_name', 'method', 'user', 'error_state', 'unique_id')] if r.get('limits_failed'): det.append(['Limits', 'violated: ' + ', '.join(quantity_label(prof, ap, q) for q in r['limits_failed'])]) sig = r.get('signatures') or {} for role in ('submitter', 'reviewer', 'approver'): x = sig.get(role) if ap['settings'].get('security.esign') or x: det.append([f'Signature ({role})', '-' if x is None else ('positive' if x['positive'] else 'negative') + f' ({x["user"]})']) out.append(dict(id=r['id'], cells=[_cell(prof, ap, q, r) for q in cols], details=det, prev=recs[i - 1]['id'] if i else None, next=recs[i + 1]['id'] if i + 1 < len(recs) else None, error_state=r['error_state'], kind=r['kind'])) return out def _f6(v, sign=''): return '-' if v is None else format(v, f'{sign}.6f') def tables(host): """Display texts of the data memory views (abm p.88-93): the data browser columns, single sample details, statistics, check / adjustment data and the audit trail.""" ap, prof = host.ap, host.AP_PROFILE cols = list(ap['browser']) head = [quantity_label(prof, ap, q) for q in cols] view = filtered(host, 'view') dele = filtered(host, 'delete') stats = statistics(host) for srow in stats: srow['cells'] = [srow['method'], str(srow['n'])] srow['details'] = [[q['label'], str(q['n']), f'{q["min"]:.6g}', f'{q["max"]:.6g}', f'{q["avg"]:.6g}', f'{q["sd"]:.3g}'] for q in srow['quantities']] checks = [dict(id=c['id'], cells=[c['time'].replace('T', ' ')[:16], c['check'], c['result']], details=[['Check', c['check']], ['Type', c['kind']], ['Date / Time', c['time'].replace('T', ' ')], ['Method', c['method'] or '-'], ['Result', c['result']], ['User', c['user']], ['Reference value', '-' if c['reference'] is None else f'{c["reference"]:.5f}'], ['Measured value', '-' if c['measured'] is None else f'{c["measured"]:.5f}'], ['Lower / upper limit', '-' if c['lower'] is None else f'{c["lower"]:.5f} / {c["upper"]:.5f}'], ['Condition', c['condition']], ['Temperature', '-' if c['temperature'] is None else f'{c["temperature"]:.2f} °C']] + [[x['q'], f'{x["value"]} ({x["lower"]} .. {x["upper"]})'] for x in c.get('rows', [])]) for c in ap['check_data']] adj = [dict(id=a['id'], cells=[a['time'].replace('T', ' ')[:16], a['type'], a['user']], details=[['Type', a['type']], ['Date / Time', a['time'].replace('T', ' ')], ['User', a['user']]] + [[f'{x["standard"]}', f'old {_f6(x["old"])} / new {_f6(x["new"])} ({_f6(x["dev_abs"], "+")})'] for x in a['rows']]) for a in ap['adjustments']] aud = [dict(id=e['id'], cells=[e['time'].replace('T', ' ')[:16], e['user'], e['text']], details=[['Date / Time', e['time'].replace('T', ' ')], ['User', e['user']], ['Entry', e['text']], ['Exported', 'yes' if e['exported'] else 'no']]) for e in ap['audit']] return dict(header=head, measured=_rows(host, view, cols), measured_filtered=bool(ap['filters']['view']), delete=_rows(host, dele, cols), delete_filtered=bool(ap['filters']['delete']), statistics=stats, checks=checks, adjustments=adj, audit=aud, filters={k: [dict(c, cells=[c['criterion'], c['comparator'], c.get('value', '')]) for c in v] for k, v in ap['filters'].items()}) def methods_view(ap): """The methods with, per method, the constants of the user functions (active flag and value set in the method, abm p.79, gsf p.35).""" out = copy.deepcopy(ap['methods']) consts = [f for f in ap['functions'] if f['type'] == 'Constant'] for m in out: m['constants_view'] = [dict(name=f['name'], active=bool(m['modules'].get(f['name'])), value=m['constants'].get(f['name'], f.get('value', 0.0))) for f in consts] return out def device_values(host): """The agent-visible slots of the device layer.""" ap, prof = host.ap, host.AP_PROFILE due = {c['name']: check_due(host, c) for c in ap['checks']} return { 'device.settings': copy.deepcopy(ap['settings']), 'device.datetime': device_iso(host), 'device.users': public_users(ap), 'device.messages': copy.deepcopy(ap['messages']), 'device.favorites': copy.deepcopy(ap['favorites']), 'device.lists': dict(printers=copy.deepcopy(ap['printers']), reports=copy.deepcopy(ap['reports']), browser=list(ap['browser']), extrapolation=copy.deepcopy(ap['extrapolation']), shares=[{k: x[k] for k in ('name', 'path', 'user')} for x in ap['shares']]), 'device.system': dict(rows=prof['system_info'](host), power_epoch=ap['power_epoch'], firmware_checked=ap['firmware_checked'], beeps=ap['beeps'], auto_printouts=ap['auto_printouts'], status=status(ap)), 'device.touch_calibration': copy.deepcopy(ap['touch_cal']), 'methods.list': methods_view(ap), 'methods.active': ap['active'], 'sample.quick_settings': copy.deepcopy(ap['quick']), 'sample.list': dict(entries=copy.deepcopy(ap['sample_list']), templates=[dict(t, index=i) for i, t in enumerate(copy.deepcopy(ap['templates']))]), 'data.measured': copy.deepcopy(ap['data']), 'data.filters': copy.deepcopy(ap['filters']), 'data.statistics': statistics(host), 'data.checks': copy.deepcopy(ap['check_data']), 'data.adjustments': copy.deepcopy(ap['adjustments']), 'data.audit_trail': copy.deepcopy(ap['audit']), 'checks.list': [dict(c, due_days=None if due[c['name']] is None else round(due[c['name']], 3)) for c in ap['checks']], 'standards.list': copy.deepcopy(ap['standards']), 'functions.list': copy.deepcopy(ap['functions']), 'functions.calculator': copy.deepcopy(ap.get('calculator')), 'run.state': prof['run_state'](host), 'display.readout': prof['readout'](host), 'quantities.list': quantities_list(prof, ap), 'display.tables': tables(host)} def device_cap_tuples(profile, components): """Device commands in the runtimes' tuple form (input, output, components, meaning, kind, visibility, example, effects).""" out = {} for k, (inp, outp, meaning, kind, right, example, effects) in DEVICE_CAPS.items(): if k not in profile['commands']: continue inp = copy.deepcopy(inp) if k == 'settings.configure': inp = obj(dict(settings=settings_schema(profile['settings']))) if k == 'methods.configure': inp = obj(dict(method=NAME, settings=method_keys(profile))) if k == 'quick.configure': inp = obj(dict(settings=quick_schema(profile))) if k == 'sample_list.edit': # measurement types of this instrument inp['properties']['entry']['properties']['type']['enum'] = [x for x in MEASUREMENT_TYPES if x in profile['modes']] if k == 'lists.edit' and 'extrapolation_default' not in profile: # the extrapolation temperatures exist on the DMA M only (gsf p.17) inp['properties']['list']['enum'].remove('extrapolation') if k == 'checks.manage' and 'check_schema' in profile: inp = obj(dict(action={'type': 'string', 'enum': ['save', 'delete']}, check=ANYOBJ, original=nullable(STR)), optional=('original',)) out[k] = (inp, outp, components.get(k, [profile['display_component']]), meaning, kind, 'agent', example, effects) return out def precondition(cap): spec = DEVICE_CAPS.get(cap) right = spec[4] if spec else None text = '仪器通电' + ('' if cap in NO_LOGON else '、已登录') + \ (f'、登录用户的组有权限{right}' if right else '') + \ ('' if cap in ('monitor.set', 'favorites.configure', 'data.filter', 'calculator.evaluate', 'firmware.check', 'user.logon', 'user.logoff', 'messages.acknowledge') else '、没有测量在进行（测量中不能保存设置）') check = '_antonpaar_touch.gate: powered, logged on, group right, not running; then the command validates on a candidate copy' if cap in ('measurement.continue', 'adjustment.decide'): # caller rule of the sessions (direct call and panel gesture alike) text += '；调用者规则：agent不能确认他人运行的下一次装样，也不能应用/放弃他人调整运行的结果（ACCESS_DENIED，状态不变）' check += '; session caller rule _antonpaar_touch.owner_guard (direct call and the command a panel gesture calls)' return dict(description_zh=text, state_ids=['power.enabled', 'device.users', 'cycle.phase'], enforced_by='runtime', check=check)