pychemstation.generated API documentation

# pychemstation.generated

View Source

     1from .pump_method import (
     2    Channel1ExtendedSolventType,
     3    Channel2ExtendedSolventType,
     4    CompressA,
     5    CompressB,
     6    Definition,
     7    PostTime,
     8    PumpMethod,
     9    SolventComposition,
    10    SolventDescription,
    11    SolventElement,
    12    StopTime,
    13    StrokeA,
    14    Timetable,
    15    TimetableEntry,
    16)
    17
    18from .dad_method import (
    19    AnalogOutput1,
    20    AnalogOutput2,
    21    DadMethod,
    22    PostTime,
    23    PrepareAutomation,
    24    PrepareMode,
    25    Signal,
    26    Signals,
    27    SpectraAcquisition,
    28    StopTime,
    29)
    30
    31__all__ = [
    32    "Channel1ExtendedSolventType",
    33    "Channel2ExtendedSolventType",
    34    "CompressA",
    35    "CompressB",
    36    "Definition",
    37    "PostTime",
    38    "PumpMethod",
    39    "SolventComposition",
    40    "SolventDescription",
    41    "SolventElement",
    42    "StopTime",
    43    "StrokeA",
    44    "Timetable",
    45    "TimetableEntry",
    46    "AnalogOutput1",
    47    "AnalogOutput2",
    48    "DadMethod",
    49    "PostTime",
    50    "PrepareAutomation",
    51    "PrepareMode",
    52    "Signal",
    53    "Signals",
    54    "SpectraAcquisition",
    55    "StopTime",
    56]

@dataclass
class Channel1ExtendedSolventType: View Source

    228@dataclass
    229class Channel1ExtendedSolventType:
    230    mode: Optional[str] = field(
    231        default=None,
    232        metadata={
    233            "name": "Mode",
    234            "type": "Element",
    235            "required": True,
    236        },
    237    )
    238    solvent_description: Optional[SolventDescription] = field(
    239        default=None,
    240        metadata={
    241            "name": "SolventDescription",
    242            "type": "Element",
    243            "required": True,
    244        },
    245    )

Channel1ExtendedSolventType( mode: Optional[str] = None, solvent_description: Optional[SolventDescription] = None)
mode: Optional[str] = None
solvent_description: Optional[SolventDescription] = None
@dataclass
class Channel2ExtendedSolventType: View Source

    248@dataclass
    249class Channel2ExtendedSolventType:
    250    mode: Optional[str] = field(
    251        default=None,
    252        metadata={
    253            "name": "Mode",
    254            "type": "Element",
    255            "required": True,
    256        },
    257    )
    258    solvent_description: Optional[SolventDescription] = field(
    259        default=None,
    260        metadata={
    261            "name": "SolventDescription",
    262            "type": "Element",
    263            "required": True,
    264        },
    265    )

Channel2ExtendedSolventType( mode: Optional[str] = None, solvent_description: Optional[SolventDescription] = None)
mode: Optional[str] = None
solvent_description: Optional[SolventDescription] = None
@dataclass
class CompressA: View Source

     7@dataclass
     8class CompressA:
     9    compressibility_mode: Optional[str] = field(
    10        default=None,
    11        metadata={
    12            "name": "CompressibilityMode",
    13            "type": "Element",
    14            "required": True,
    15        },
    16    )
    17    compressibility_value_set: Optional[int] = field(
    18        default=None,
    19        metadata={
    20            "name": "CompressibilityValueSet",
    21            "type": "Element",
    22            "required": True,
    23        },
    24    )

CompressA( compressibility_mode: Optional[str] = None, compressibility_value_set: Optional[int] = None)
compressibility_mode: Optional[str] = None
compressibility_value_set: Optional[int] = None
@dataclass
class CompressB: View Source

    27@dataclass
    28class CompressB:
    29    compressibility_mode: Optional[str] = field(
    30        default=None,
    31        metadata={
    32            "name": "CompressibilityMode",
    33            "type": "Element",
    34            "required": True,
    35        },
    36    )
    37    compressibility_value_set: Optional[int] = field(
    38        default=None,
    39        metadata={
    40            "name": "CompressibilityValueSet",
    41            "type": "Element",
    42            "required": True,
    43        },
    44    )

CompressB( compressibility_mode: Optional[str] = None, compressibility_value_set: Optional[int] = None)
compressibility_mode: Optional[str] = None
compressibility_value_set: Optional[int] = None
@dataclass
class Definition: View Source

    47@dataclass
    48class Definition:
    49    name: Optional[str] = field(
    50        default=None,
    51        metadata={
    52            "name": "Name",
    53            "type": "Element",
    54            "required": True,
    55        },
    56    )
    57    is_pure: Optional[bool] = field(
    58        default=None,
    59        metadata={
    60            "name": "IsPure",
    61            "type": "Element",
    62            "required": True,
    63        },
    64    )
    65    crc: Optional[int] = field(
    66        default=None,
    67        metadata={
    68            "name": "CRC",
    69            "type": "Element",
    70            "required": True,
    71        },
    72    )
    73    solvent_stripes: list[str] = field(
    74        default_factory=list,
    75        metadata={
    76            "name": "SolventStripes",
    77            "type": "Element",
    78            "min_occurs": 1,
    79        },
    80    )

Definition( name: Optional[str] = None, is_pure: Optional[bool] = None, crc: Optional[int] = None, solvent_stripes: list[str] = <factory>)
name: Optional[str] = None
is_pure: Optional[bool] = None
crc: Optional[int] = None
solvent_stripes: list[str]
@dataclass
class PostTime: View Source

    46@dataclass
    47class PostTime:
    48    post_time_mode: Optional[str] = field(
    49        default=None,
    50        metadata={
    51            "name": "PostTimeMode",
    52            "type": "Element",
    53            "required": True,
    54        },
    55    )

PostTime(post_time_mode: Optional[str] = None)
post_time_mode: Optional[str] = None
@dataclass
class PumpMethod: View Source

    351@dataclass
    352class PumpMethod:
    353    module_type: Optional[str] = field(
    354        default=None,
    355        metadata={
    356            "name": "ModuleType",
    357            "type": "Attribute",
    358            "required": True,
    359        },
    360    )
    361    xsd_name: Optional[str] = field(
    362        default=None,
    363        metadata={
    364            "name": "xsdName",
    365            "type": "Attribute",
    366            "required": True,
    367        },
    368    )
    369    schema_version: Optional[str] = field(
    370        default=None,
    371        metadata={
    372            "name": "schemaVersion",
    373            "type": "Attribute",
    374            "required": True,
    375        },
    376    )
    377    schema_si: Optional[int] = field(
    378        default=None,
    379        metadata={
    380            "name": "schemaSI",
    381            "type": "Attribute",
    382            "required": True,
    383        },
    384    )
    385    module_options: Optional[object] = field(
    386        default=None,
    387        metadata={
    388            "name": "ModuleOptions",
    389            "type": "Attribute",
    390            "required": True,
    391        },
    392    )
    393    configuration_xml: Optional[str] = field(
    394        default=None,
    395        metadata={
    396            "name": "ConfigurationXml",
    397            "type": "Element",
    398            "required": True,
    399        },
    400    )
    401    timetable: Optional[Timetable] = field(
    402        default=None,
    403        metadata={
    404            "name": "Timetable",
    405            "type": "Element",
    406            "required": True,
    407        },
    408    )
    409    stop_time: Optional[StopTime] = field(
    410        default=None,
    411        metadata={
    412            "name": "StopTime",
    413            "type": "Element",
    414            "required": True,
    415        },
    416    )
    417    post_time: Optional[PostTime] = field(
    418        default=None,
    419        metadata={
    420            "name": "PostTime",
    421            "type": "Element",
    422            "required": True,
    423        },
    424    )
    425    flow: Optional[float] = field(
    426        default=None,
    427        metadata={
    428            "name": "Flow",
    429            "type": "Element",
    430            "required": True,
    431        },
    432    )
    433    use_solvent_types: Optional[bool] = field(
    434        default=None,
    435        metadata={
    436            "name": "UseSolventTypes",
    437            "type": "Element",
    438            "required": True,
    439        },
    440    )
    441    stroke_mode: Optional[str] = field(
    442        default=None,
    443        metadata={
    444            "name": "StrokeMode",
    445            "type": "Element",
    446            "required": True,
    447        },
    448    )
    449    stroke_a: Optional[StrokeA] = field(
    450        default=None,
    451        metadata={
    452            "name": "StrokeA",
    453            "type": "Element",
    454            "required": True,
    455        },
    456    )
    457    compress_a: Optional[CompressA] = field(
    458        default=None,
    459        metadata={
    460            "name": "CompressA",
    461            "type": "Element",
    462            "required": True,
    463        },
    464    )
    465    compress_b: Optional[CompressB] = field(
    466        default=None,
    467        metadata={
    468            "name": "CompressB",
    469            "type": "Element",
    470            "required": True,
    471        },
    472    )
    473    solvent_composition: Optional[SolventComposition] = field(
    474        default=None,
    475        metadata={
    476            "name": "SolventComposition",
    477            "type": "Element",
    478            "required": True,
    479        },
    480    )
    481    low_pressure_limit: Optional[int] = field(
    482        default=None,
    483        metadata={
    484            "name": "LowPressureLimit",
    485            "type": "Element",
    486            "required": True,
    487        },
    488    )
    489    high_pressure_limit: Optional[int] = field(
    490        default=None,
    491        metadata={
    492            "name": "HighPressureLimit",
    493            "type": "Element",
    494            "required": True,
    495        },
    496    )
    497    maximum_flow_ramp: Optional[int] = field(
    498        default=None,
    499        metadata={
    500            "name": "MaximumFlowRamp",
    501            "type": "Element",
    502            "required": True,
    503        },
    504    )
    505    flow_ramp_down: Optional[int] = field(
    506        default=None,
    507        metadata={
    508            "name": "FlowRampDown",
    509            "type": "Element",
    510            "required": True,
    511        },
    512    )
    513    expected_mixer_type: Optional[str] = field(
    514        default=None,
    515        metadata={
    516            "name": "ExpectedMixerType",
    517            "type": "Element",
    518            "required": True,
    519        },
    520    )

PumpMethod( module_type: Optional[str] = None, xsd_name: Optional[str] = None, schema_version: Optional[str] = None, schema_si: Optional[int] = None, module_options: Optional[object] = None, configuration_xml: Optional[str] = None, timetable: Optional[Timetable] = None, stop_time: Optional[StopTime] = None, post_time: Optional[PostTime] = None, flow: Optional[float] = None, use_solvent_types: Optional[bool] = None, stroke_mode: Optional[str] = None, stroke_a: Optional[StrokeA] = None, compress_a: Optional[CompressA] = None, compress_b: Optional[CompressB] = None, solvent_composition: Optional[SolventComposition] = None, low_pressure_limit: Optional[int] = None, high_pressure_limit: Optional[int] = None, maximum_flow_ramp: Optional[int] = None, flow_ramp_down: Optional[int] = None, expected_mixer_type: Optional[str] = None)
module_type: Optional[str] = None
xsd_name: Optional[str] = None
schema_version: Optional[str] = None
schema_si: Optional[int] = None
module_options: Optional[object] = None
configuration_xml: Optional[str] = None
timetable: Optional[Timetable] = None
stop_time: Optional[StopTime] = None
post_time: Optional[PostTime] = None
flow: Optional[float] = None
use_solvent_types: Optional[bool] = None
stroke_mode: Optional[str] = None
stroke_a: Optional[StrokeA] = None
compress_a: Optional[CompressA] = None
compress_b: Optional[CompressB] = None
solvent_composition: Optional[SolventComposition] = None
low_pressure_limit: Optional[int] = None
high_pressure_limit: Optional[int] = None
maximum_flow_ramp: Optional[int] = None
flow_ramp_down: Optional[int] = None
expected_mixer_type: Optional[str] = None
@dataclass
class SolventComposition: View Source

    339@dataclass
    340class SolventComposition:
    341    solvent_element: list[SolventElement] = field(
    342        default_factory=list,
    343        metadata={
    344            "name": "SolventElement",
    345            "type": "Element",
    346            "min_occurs": 1,
    347        },
    348    )

SolventComposition( solvent_element: list[SolventElement] = <factory>)
solvent_element: list[SolventElement]
@dataclass
class SolventDescription: View Source

    196@dataclass
    197class SolventDescription:
    198    definition: Optional[Definition] = field(
    199        default=None,
    200        metadata={
    201            "name": "Definition",
    202            "type": "Element",
    203            "required": True,
    204        },
    205    )
    206    percent: Optional[int] = field(
    207        default=None,
    208        metadata={
    209            "name": "Percent",
    210            "type": "Element",
    211            "required": True,
    212        },
    213    )

SolventDescription( definition: Optional[Definition] = None, percent: Optional[int] = None)
definition: Optional[Definition] = None
percent: Optional[int] = None
@dataclass
class SolventElement: View Source

    268@dataclass
    269class SolventElement:
    270    channel: Optional[str] = field(
    271        default=None,
    272        metadata={
    273            "name": "Channel",
    274            "type": "Element",
    275            "required": True,
    276        },
    277    )
    278    channel1_user_name: Optional[str] = field(
    279        default=None,
    280        metadata={
    281            "name": "Channel1UserName",
    282            "type": "Element",
    283            "required": True,
    284        },
    285    )
    286    channel2_user_name: Optional[object] = field(
    287        default=None,
    288        metadata={
    289            "name": "Channel2UserName",
    290            "type": "Element",
    291        },
    292    )
    293    selected_solvent_channel: Optional[str] = field(
    294        default=None,
    295        metadata={
    296            "name": "SelectedSolventChannel",
    297            "type": "Element",
    298            "required": True,
    299        },
    300    )
    301    used: Optional[bool] = field(
    302        default=None,
    303        metadata={
    304            "name": "Used",
    305            "type": "Element",
    306            "required": True,
    307        },
    308    )
    309    percentage: Optional[int] = field(
    310        default=None,
    311        metadata={
    312            "name": "Percentage",
    313            "type": "Element",
    314            "required": True,
    315        },
    316    )
    317    channel1_extended_solvent_type: Optional[Channel1ExtendedSolventType] = (
    318        field(
    319            default=None,
    320            metadata={
    321                "name": "Channel1ExtendedSolventType",
    322                "type": "Element",
    323                "required": True,
    324            },
    325        )
    326    )
    327    channel2_extended_solvent_type: Optional[Channel2ExtendedSolventType] = (
    328        field(
    329            default=None,
    330            metadata={
    331                "name": "Channel2ExtendedSolventType",
    332                "type": "Element",
    333                "required": True,
    334            },
    335        )
    336    )

SolventElement( channel: Optional[str] = None, channel1_user_name: Optional[str] = None, channel2_user_name: Optional[object] = None, selected_solvent_channel: Optional[str] = None, used: Optional[bool] = None, percentage: Optional[int] = None, channel1_extended_solvent_type: Optional[Channel1ExtendedSolventType] = None, channel2_extended_solvent_type: Optional[Channel2ExtendedSolventType] = None)
channel: Optional[str] = None
channel1_user_name: Optional[str] = None
channel2_user_name: Optional[object] = None
selected_solvent_channel: Optional[str] = None
used: Optional[bool] = None
percentage: Optional[int] = None
channel1_extended_solvent_type: Optional[Channel1ExtendedSolventType] = None
channel2_extended_solvent_type: Optional[Channel2ExtendedSolventType] = None
@dataclass
class StopTime: View Source

    192@dataclass
    193class StopTime:
    194    stop_time_mode: Optional[str] = field(
    195        default=None,
    196        metadata={
    197            "name": "StopTimeMode",
    198            "type": "Element",
    199            "required": True,
    200        },
    201    )

StopTime(stop_time_mode: Optional[str] = None)
stop_time_mode: Optional[str] = None
@dataclass
class StrokeA: View Source

    123@dataclass
    124class StrokeA:
    125    automatic_stroke_calculation: Optional[bool] = field(
    126        default=None,
    127        metadata={
    128            "name": "AutomaticStrokeCalculation",
    129            "type": "Element",
    130            "required": True,
    131        },
    132    )

StrokeA(automatic_stroke_calculation: Optional[bool] = None)
automatic_stroke_calculation: Optional[bool] = None
@dataclass
class Timetable: View Source

    216@dataclass
    217class Timetable:
    218    timetable_entry: list[TimetableEntry] = field(
    219        default_factory=list,
    220        metadata={
    221            "name": "TimetableEntry",
    222            "type": "Element",
    223            "min_occurs": 1,
    224        },
    225    )

Timetable( timetable_entry: list[TimetableEntry] = <factory>)
timetable_entry: list[TimetableEntry]
@dataclass
class TimetableEntry: View Source

    135@dataclass
    136class TimetableEntry:
    137    type_value: Optional[QName] = field(
    138        default=None,
    139        metadata={
    140            "name": "type",
    141            "type": "Attribute",
    142            "namespace": "http://www.w3.org/2001/XMLSchema-instance",
    143            "required": True,
    144        },
    145    )
    146    object_id: Optional[str] = field(
    147        default=None,
    148        metadata={
    149            "name": "ObjectID",
    150            "type": "Attribute",
    151            "required": True,
    152        },
    153    )
    154    time: Optional[float] = field(
    155        default=None,
    156        metadata={
    157            "name": "Time",
    158            "type": "Element",
    159            "required": True,
    160        },
    161    )
    162    percent_a: Optional[int] = field(
    163        default=None,
    164        metadata={
    165            "name": "PercentA",
    166            "type": "Element",
    167            "required": True,
    168        },
    169    )
    170    percent_b: Optional[int] = field(
    171        default=None,
    172        metadata={
    173            "name": "PercentB",
    174            "type": "Element",
    175            "required": True,
    176        },
    177    )
    178    percent_c: Optional[int] = field(
    179        default=None,
    180        metadata={
    181            "name": "PercentC",
    182            "type": "Element",
    183            "required": True,
    184        },
    185    )
    186    percent_d: Optional[int] = field(
    187        default=None,
    188        metadata={
    189            "name": "PercentD",
    190            "type": "Element",
    191            "required": True,
    192        },
    193    )

TimetableEntry( type_value: Optional[xml.etree.ElementTree.QName] = None, object_id: Optional[str] = None, time: Optional[float] = None, percent_a: Optional[int] = None, percent_b: Optional[int] = None, percent_c: Optional[int] = None, percent_d: Optional[int] = None)
type_value: Optional[xml.etree.ElementTree.QName] = None
object_id: Optional[str] = None
time: Optional[float] = None
percent_a: Optional[int] = None
percent_b: Optional[int] = None
percent_c: Optional[int] = None
percent_d: Optional[int] = None
@dataclass
class AnalogOutput1: View Source

     6@dataclass
     7class AnalogOutput1:
     8    analog_zero: Optional[int] = field(
     9        default=None,
    10        metadata={
    11            "name": "AnalogZero",
    12            "type": "Element",
    13            "required": True,
    14        },
    15    )
    16    analog_att: Optional[int] = field(
    17        default=None,
    18        metadata={
    19            "name": "AnalogAtt",
    20            "type": "Element",
    21            "required": True,
    22        },
    23    )

AnalogOutput1(analog_zero: Optional[int] = None, analog_att: Optional[int] = None)
analog_zero: Optional[int] = None
analog_att: Optional[int] = None
@dataclass
class AnalogOutput2: View Source

    26@dataclass
    27class AnalogOutput2:
    28    analog_zero: Optional[int] = field(
    29        default=None,
    30        metadata={
    31            "name": "AnalogZero",
    32            "type": "Element",
    33            "required": True,
    34        },
    35    )
    36    analog_att: Optional[int] = field(
    37        default=None,
    38        metadata={
    39            "name": "AnalogAtt",
    40            "type": "Element",
    41            "required": True,
    42        },
    43    )

AnalogOutput2(analog_zero: Optional[int] = None, analog_att: Optional[int] = None)
analog_zero: Optional[int] = None
analog_att: Optional[int] = None
@dataclass
class DadMethod: View Source

    216@dataclass
    217class DadMethod:
    218    module_type: Optional[str] = field(
    219        default=None,
    220        metadata={
    221            "name": "ModuleType",
    222            "type": "Attribute",
    223            "required": True,
    224        },
    225    )
    226    schema_version: Optional[str] = field(
    227        default=None,
    228        metadata={
    229            "name": "schemaVersion",
    230            "type": "Attribute",
    231            "required": True,
    232        },
    233    )
    234    schema_si: Optional[int] = field(
    235        default=None,
    236        metadata={
    237            "name": "schemaSI",
    238            "type": "Attribute",
    239            "required": True,
    240        },
    241    )
    242    module_options: Optional[object] = field(
    243        default=None,
    244        metadata={
    245            "name": "ModuleOptions",
    246            "type": "Attribute",
    247            "required": True,
    248        },
    249    )
    250    configuration_xml: Optional[str] = field(
    251        default=None,
    252        metadata={
    253            "name": "ConfigurationXml",
    254            "type": "Element",
    255            "required": True,
    256        },
    257    )
    258    timetable: Optional[object] = field(
    259        default=None,
    260        metadata={
    261            "name": "Timetable",
    262            "type": "Element",
    263        },
    264    )
    265    stop_time: Optional[StopTime] = field(
    266        default=None,
    267        metadata={
    268            "name": "StopTime",
    269            "type": "Element",
    270            "required": True,
    271        },
    272    )
    273    post_time: Optional[PostTime] = field(
    274        default=None,
    275        metadata={
    276            "name": "PostTime",
    277            "type": "Element",
    278            "required": True,
    279        },
    280    )
    281    delay: Optional[int] = field(
    282        default=None,
    283        metadata={
    284            "name": "Delay",
    285            "type": "Element",
    286            "required": True,
    287        },
    288    )
    289    analog_output1: Optional[AnalogOutput1] = field(
    290        default=None,
    291        metadata={
    292            "name": "AnalogOutput1",
    293            "type": "Element",
    294            "required": True,
    295        },
    296    )
    297    analog_output2: Optional[AnalogOutput2] = field(
    298        default=None,
    299        metadata={
    300            "name": "AnalogOutput2",
    301            "type": "Element",
    302            "required": True,
    303        },
    304    )
    305    signals: Optional[Signals] = field(
    306        default=None,
    307        metadata={
    308            "name": "Signals",
    309            "type": "Element",
    310            "required": True,
    311        },
    312    )
    313    peakwidth: Optional[int] = field(
    314        default=None,
    315        metadata={
    316            "name": "Peakwidth",
    317            "type": "Element",
    318            "required": True,
    319        },
    320    )
    321    slitwidth: Optional[int] = field(
    322        default=None,
    323        metadata={
    324            "name": "Slitwidth",
    325            "type": "Element",
    326            "required": True,
    327        },
    328    )
    329    uvlamp_required: Optional[bool] = field(
    330        default=None,
    331        metadata={
    332            "name": "UVLampRequired",
    333            "type": "Element",
    334            "required": True,
    335        },
    336    )
    337    vislamp_required: Optional[bool] = field(
    338        default=None,
    339        metadata={
    340            "name": "VISLampRequired",
    341            "type": "Element",
    342            "required": True,
    343        },
    344    )
    345    prepare_mode: Optional[PrepareMode] = field(
    346        default=None,
    347        metadata={
    348            "name": "PrepareMode",
    349            "type": "Element",
    350            "required": True,
    351        },
    352    )
    353    prepare_automation: Optional[PrepareAutomation] = field(
    354        default=None,
    355        metadata={
    356            "name": "PrepareAutomation",
    357            "type": "Element",
    358            "required": True,
    359        },
    360    )
    361    spectra_acquisition: Optional[SpectraAcquisition] = field(
    362        default=None,
    363        metadata={
    364            "name": "SpectraAcquisition",
    365            "type": "Element",
    366            "required": True,
    367        },
    368    )

DadMethod( module_type: Optional[str] = None, schema_version: Optional[str] = None, schema_si: Optional[int] = None, module_options: Optional[object] = None, configuration_xml: Optional[str] = None, timetable: Optional[object] = None, stop_time: Optional[StopTime] = None, post_time: Optional[PostTime] = None, delay: Optional[int] = None, analog_output1: Optional[AnalogOutput1] = None, analog_output2: Optional[AnalogOutput2] = None, signals: Optional[Signals] = None, peakwidth: Optional[int] = None, slitwidth: Optional[int] = None, uvlamp_required: Optional[bool] = None, vislamp_required: Optional[bool] = None, prepare_mode: Optional[PrepareMode] = None, prepare_automation: Optional[PrepareAutomation] = None, spectra_acquisition: Optional[SpectraAcquisition] = None)
module_type: Optional[str] = None
schema_version: Optional[str] = None
schema_si: Optional[int] = None
module_options: Optional[object] = None
configuration_xml: Optional[str] = None
timetable: Optional[object] = None
stop_time: Optional[StopTime] = None
post_time: Optional[PostTime] = None
delay: Optional[int] = None
analog_output1: Optional[AnalogOutput1] = None
analog_output2: Optional[AnalogOutput2] = None
signals: Optional[Signals] = None
peakwidth: Optional[int] = None
slitwidth: Optional[int] = None
uvlamp_required: Optional[bool] = None
vislamp_required: Optional[bool] = None
prepare_mode: Optional[PrepareMode] = None
prepare_automation: Optional[PrepareAutomation] = None
spectra_acquisition: Optional[SpectraAcquisition] = None
@dataclass
class PrepareAutomation: View Source

    58@dataclass
    59class PrepareAutomation:
    60    do_prep_run_balance: Optional[bool] = field(
    61        default=None,
    62        metadata={
    63            "name": "DoPrepRunBalance",
    64            "type": "Element",
    65            "required": True,
    66        },
    67    )
    68    do_start_run_balance: Optional[bool] = field(
    69        default=None,
    70        metadata={
    71            "name": "DoStartRunBalance",
    72            "type": "Element",
    73            "required": True,
    74        },
    75    )
    76    do_post_run_balance: Optional[bool] = field(
    77        default=None,
    78        metadata={
    79            "name": "DoPostRunBalance",
    80            "type": "Element",
    81            "required": True,
    82        },
    83    )

PrepareAutomation( do_prep_run_balance: Optional[bool] = None, do_start_run_balance: Optional[bool] = None, do_post_run_balance: Optional[bool] = None)
do_prep_run_balance: Optional[bool] = None
do_start_run_balance: Optional[bool] = None
do_post_run_balance: Optional[bool] = None
@dataclass
class PrepareMode: View Source

     86@dataclass
     87class PrepareMode:
     88    balance_mode: Optional[str] = field(
     89        default=None,
     90        metadata={
     91            "name": "BalanceMode",
     92            "type": "Element",
     93            "required": True,
     94        },
     95    )
     96    headroom: Optional[int] = field(
     97        default=None,
     98        metadata={
     99            "name": "Headroom",
    100            "type": "Element",
    101            "required": True,
    102        },
    103    )
    104    smpgain: Optional[int] = field(
    105        default=None,
    106        metadata={
    107            "name": "SMPGain",
    108            "type": "Element",
    109            "required": True,
    110        },
    111    )

PrepareMode( balance_mode: Optional[str] = None, headroom: Optional[int] = None, smpgain: Optional[int] = None)
balance_mode: Optional[str] = None
headroom: Optional[int] = None
smpgain: Optional[int] = None
@dataclass
class Signal: View Source

    114@dataclass
    115class Signal:
    116    use_signal: Optional[bool] = field(
    117        default=None,
    118        metadata={
    119            "name": "UseSignal",
    120            "type": "Element",
    121            "required": True,
    122        },
    123    )
    124    id: Optional[str] = field(
    125        default=None,
    126        metadata={
    127            "name": "ID",
    128            "type": "Element",
    129            "required": True,
    130        },
    131    )
    132    wavelength: Optional[int] = field(
    133        default=None,
    134        metadata={
    135            "name": "Wavelength",
    136            "type": "Element",
    137        },
    138    )
    139    bandwidth: Optional[int] = field(
    140        default=None,
    141        metadata={
    142            "name": "Bandwidth",
    143            "type": "Element",
    144        },
    145    )
    146    use_reference: Optional[bool] = field(
    147        default=None,
    148        metadata={
    149            "name": "UseReference",
    150            "type": "Element",
    151            "required": True,
    152        },
    153    )

Signal( use_signal: Optional[bool] = None, id: Optional[str] = None, wavelength: Optional[int] = None, bandwidth: Optional[int] = None, use_reference: Optional[bool] = None)
use_signal: Optional[bool] = None
id: Optional[str] = None
wavelength: Optional[int] = None
bandwidth: Optional[int] = None
use_reference: Optional[bool] = None
@dataclass
class Signals: View Source

    204@dataclass
    205class Signals:
    206    signal: list[Signal] = field(
    207        default_factory=list,
    208        metadata={
    209            "name": "Signal",
    210            "type": "Element",
    211            "min_occurs": 1,
    212        },
    213    )

Signals(signal: list[Signal] = <factory>)
signal: list[Signal]
@dataclass
class SpectraAcquisition: View Source

    156@dataclass
    157class SpectraAcquisition:
    158    spectra_range_from: Optional[int] = field(
    159        default=None,
    160        metadata={
    161            "name": "SpectraRangeFrom",
    162            "type": "Element",
    163            "required": True,
    164        },
    165    )
    166    spectra_range_to: Optional[int] = field(
    167        default=None,
    168        metadata={
    169            "name": "SpectraRangeTo",
    170            "type": "Element",
    171            "required": True,
    172        },
    173    )
    174    spectra_step: Optional[int] = field(
    175        default=None,
    176        metadata={
    177            "name": "SpectraStep",
    178            "type": "Element",
    179            "required": True,
    180        },
    181    )
    182    spectra_acq_mode: Optional[str] = field(
    183        default=None,
    184        metadata={
    185            "name": "SpectraAcqMode",
    186            "type": "Element",
    187            "required": True,
    188        },
    189    )

SpectraAcquisition( spectra_range_from: Optional[int] = None, spectra_range_to: Optional[int] = None, spectra_step: Optional[int] = None, spectra_acq_mode: Optional[str] = None)
spectra_range_from: Optional[int] = None
spectra_range_to: Optional[int] = None
spectra_step: Optional[int] = None
spectra_acq_mode: Optional[str] = None