| """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_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) |
|
|
|
|
| |
| 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}') |
|
|
|
|
| |
| 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') |
|
|
| |
| |
| MSERIES_SETTINGS = [ |
| |
| 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'), |
| |
| 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'), |
| |
| 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'), |
| |
| 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'), |
| |
| 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 = { |
| '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}} |
|
|
| |
| 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') |
|
|
| |
| 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_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') |
|
|
|
|
| |
| 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 |
| 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) |
|
|
|
|
| |
| 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}' |
|
|
|
|
| |
| 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: |
| del ap['audit'][:-999] |
|
|
|
|
| |
| 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 |
|
|
|
|
| |
| _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'] |
| 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 |
| 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 |
|
|
|
|
| |
| 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'): |
| 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) |
|
|
|
|
| |
| 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)), '选择方法（主屏<Method>）：方法温度等写入快速设置并下发到测量单元', |
| '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)), '快速设置（主屏<Quick Settings>）：样品名、测量类型与本次测量参数，' |
| '保留到下次修改', '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)), '按当前方法与快速设置开始测量（主屏<Start>）：等待恒温、保持时间、' |
| '按精度设定的稳定时间读数，超时中止；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))), '数据存储筛选（<Filter>：添加条件、比较符、值；删除一条或全部；条件之间为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 |
| 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 |
|
|
|
|
| |
| 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'] = [] |
| 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 |
| if new.get('security.increased') and not old.get('security.increased'): |
| for u in ap['users']: |
| 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 |
| _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'] = [] |
|
|
|
|
| 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() |
|
|
|
|
| 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: |
| u['active'] = False |
| 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') |
| need(not inc or len(a['name']) >= 6, 'NOT_ALLOWED') |
| 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 |
| 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') |
| 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') |
| need(pw not in u['history'][-5:], 'NOT_ALLOWED') |
| 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') |
| 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') |
| 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') |
| 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') |
| 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')}, |
| |
| 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']: |
| 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') |
| 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: |
| 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)) |
| 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: |
| 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(): |
| 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) |
| 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') |
| 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'): |
| 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: |
| 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') |
| 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'] = [] |
| 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 |
| 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']: |
| 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') |
| 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') |
| need(rec['signatures'][mine] is None, 'NOT_ALLOWED') |
| 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']] |
| 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') |
| 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') |
| 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') |
| 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 |
| 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') |
| 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') |
| if t == 'Table' and 'table' not in a['function'] and old['type'] == 'Table': |
| f['table'] = copy.deepcopy(old['table']) |
| 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') |
| 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') |
| 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')]) |
| 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'] |
| need(all(abs(p[0] - t[0]) <= 40 and abs(p[1] - t[1]) <= 40 for p, t in zip(pts, targets)), 'NOT_ALLOWED') |
| 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) |
| 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} |
|
|
|
|
| |
| 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'): |
| 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 |
| 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 |
|
|
|
|
| |
| |
| |
| |
| 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') |
| 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']: |
| 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') |
| 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) |
| if pre is None: |
| prof['precheck'](host, run) |
| ap['run'] = run |
| out = prof['begin'](host, run) |
| run['op'] = host.operation_id |
| 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): |
| 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': |
| 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': |
| run['empty_left'] -= h |
| if run['empty_left'] <= 1e-9: |
| host.phase = 'succeeded' |
| 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': |
| 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']) |
| 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: |
| prof['direct_done'](host, reading) |
| return |
| if run.get('pre'): |
| 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': |
| 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) |
| 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)) |
| 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) |
| 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 |
| 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): |
| """<Stop> 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 |
|
|
|
|
| |
| 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 |
|
|
|
|
| |
| def panel_engine(): |
| try: |
| from asset_runtime import _panel_ui as engine |
| return engine |
| except ImportError: |
| 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: |
| 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 [] |
| 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)) |
| 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: |
| 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) |
|
|
|
|
| |
| 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': |
| 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: |
| 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'): |
| 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) |
|
|
