Sepasoft Articles

https://docs.sepasoft.com/articles/
Admin
A collection of documentation, tutorials, and knowledge base articles providing information and...
Tokens:1,439,987
Snippets:17,568
Trust Score:8.7
Update:4 months ago
Show doc for...
Tokens:
Raw
### Minimal Example: Execute Entry Command

Source: https://docs.sepasoft.com/articles/user-manual/executeentrycommandasync-batchqueueentry-batchqueueentry-string-command

A basic example demonstrating how to get a batch queue entry and start it using the synchronous executeEntryCommand.

```Python
entry = system.mes.batch.queue.getEntry("BATCH-2026-0042")
system.mes.batch.queue.executeEntryCommand(entry, 
system.mes.batch.queue.COMMAND_START())
```

--------------------------------

### Minimal Example: Execute Entry Command Asynchronously

Source: https://docs.sepasoft.com/articles/user-manual/executeentrycommandasync-batchqueueentry-batchqueueentry-string-command

Demonstrates getting a batch queue entry and initiating a START command asynchronously with a specified timeout.

```Python
entry = system.mes.batch.queue.getEntry('221205_a')
command = system.mes.batch.queue.COMMAND_START()
system.mes.batch.queue.executeEntryCommandAsync(entry, command, 5000)
```

--------------------------------

### Minimal Example: Get and Print Template Name

Source: https://docs.sepasoft.com/articles/user-manual/system-mes-getbatchcommandsignaturetemplate-commandname

Demonstrates how to retrieve a signature template for the 'Start' command and print its name if it exists. Requires the template to be not None.

```Python
template = system.mes.signature.getBatchCommandSignatureTemplate("Start")
if template is not None:
	print template.getName()
```

--------------------------------

### Example: Create Sample with Scheduled Start Time

Source: https://docs.sepasoft.com/articles/user-manual/system-mes-spc-sample-getnewbydefname-defname-locationpath

Shows how to create a sample, set its scheduled start time using the current system time, and then update the sample.

```Python
locationPath = 'Enterprise\El Dorado Hills\Test\location1'
defName = 'ManualSingleMeasurement'
sample = system.mes.spc.sample.getNewByDefName(defName, locationPath)
sample.setScheduledStart(system.date.now())
system.mes.spc.sample.update(sample, False)
```

--------------------------------

### Minimal executeEntryCommandAsync Example

Source: https://docs.sepasoft.com/articles/user-manual/executeentrycommandasync-batchqueueentry-batchqueueentry-string-command-string-changedby

A basic example showing how to start a batch queue entry asynchronously. Ensure the batch entry exists and the command is valid.

```Python
entry = system.mes.batch.queue.getEntry("BATCH-2026-0042")
system.mes.batch.queue.executeEntryCommandAsync(
	entry,
	system.mes.batch.queue.COMMAND_START()
)
```

--------------------------------

### Minimal executeStep Example

Source: https://docs.sepasoft.com/articles/project-imported-manual/system-mes-batch-queue-executestep-batchqueueentry-path

This minimal example demonstrates how to get a batch queue entry and then immediately execute a specific step using the executeStep function. Ensure the batch queue entry is valid and the path to the step is correct.

```python
entry = system.mes.batch.queue.getEntry("BATCH-2026-0042")
system.mes.batch.queue.executeStep(entry, "/{}/Mix_UP/Mix_Op:Weigh_Add", "operator1")
```

--------------------------------

### Execute Batch Start Command

Source: https://docs.sepasoft.com/articles/user-manual/system-mes-batch-queue-command_start

Executes the 'Start' command on a specific batch entry. This example demonstrates passing the COMMAND_START() token to the executeEntryCommand function.

```Python
entry = system.mes.batch.queue.getEntry("BATCH-2026-0042")
system.mes.batch.queue.executeEntryCommand(
	entry,
	system.mes.batch.queue.COMMAND_START(),
	changedBy="operatorScreen"
)
```

--------------------------------

### Complex executeStep Example with Prerequisites

Source: https://docs.sepasoft.com/articles/project-imported-manual/system-mes-batch-queue-executestep-batchqueueentry-path

This complex example shows a typical pattern for using executeStep. It includes getting the batch entry, defining the step path, and comments on optional prerequisites like handling messages or parameters before executing the step. It also shows using system.security.getUsername() for the 'changedBy' parameter.

```python
batchId = "BATCH-2026-0042"
entry = system.mes.batch.queue.getEntry(batchId)
phasePath = "/{}/Ferment_UP/Ferment_Op:Inoculate_Phase"

# Optional: ensure messages/parameters are handled before forcing step execution
# system.mes.batch.queue.assignMessageValue(msg)

system.mes.batch.queue.executeStep(entry, phasePath, system.security.getUsername())
```

--------------------------------

### Minimal executeEntryCommandBlocking Example

Source: https://docs.sepasoft.com/articles/user-manual/executeentrycommandblocking-batchqueueentry-batchqueueentry-string-command

Demonstrates the basic usage of executeEntryCommandBlocking to start a batch queue entry. Ensure the batch queue entry object is retrieved first.

```python
entry = system.mes.batch.queue.getEntry("BATCH-2026-0042")
system.mes.batch.queue.executeEntryCommandBlocking(
	entry,
	system.mes.batch.queue.COMMAND_START()
)
```

--------------------------------

### Scheduling Operations with system.mes.pasteSchedule

Source: https://docs.sepasoft.com/articles/user-manual/system-mes-pasteschedule

This example demonstrates how to load a schedule using system.mes.loadSchedule and then paste it to a specific equipment link with a preferred start time using system.mes.pasteSchedule. Ensure you have the necessary MES object links and schedule IDs.

```Python
from java.util import Calendar

begin = Calendar.getInstance()
begin.add(Calendar.DAY_OF_MONTH, -30)
start = begin.getTime()

#Get the MES object link of Unload Station 1
eqPath = 'My Enterprise\California\Receiving\Unload Station 1'
eqLink = system.mes.getMESObjectLinkByEquipmentPath(eqPath)

#Get the MES object list containing the schedule details
schedule = system.mes.loadSchedule('14850859-fe9e-4aa8-a9d2-856022ef1bb3')
system.mes.pasteSchedule(schedule, eqLink, start)
```

--------------------------------

### Get Scheduled Start Time

Source: https://docs.sepasoft.com/articles/user-manual/Sample

Retrieves the scheduled start date and time for a sample. For automatic samplings, this value will be None. This example demonstrates fetching the scheduled start time for a sample.

```Python
#You pass your location path
locationPath = 'Nuts Unlimited\Folsom\Packaging\Packaging Line 1\Line 1 Quality'
sampleDefName = 'Nut Defects'
sample = system.mes.spc.sample.data.getNewByDefName(sampleDefName, locationPath)
print sample.getScheduledStart()
```

--------------------------------

### Get Unit Procedure Name Example

Source: https://docs.sepasoft.com/articles/project-imported-manual/batchqueueentry-object

Example output showing a unit procedure name.

```javascript
>>> 
Kettle A
>>>

```

--------------------------------

### Begin Operation Example

Source: https://docs.sepasoft.com/articles/user-manual/system-mes-beginoperation

This Python snippet demonstrates how to begin an operation using system.mes.beginOperation. It involves loading an operations definition, creating an operation response, and then calling beginOperation with the equipment path and the created response.

```Python
eqPath = 'My Enterprise\California\Receiving\Unload Station 1'
#load the operations definition
operDef = system.mes.loadMESObject('Receive Material', 'OperationsDefinition')
#create an operation for the operations definition
operResp = system.mes.createOperation(operDef)
#Begin the operation
system.mes.beginOperation(eqPath, operResp)
```

--------------------------------

### Minimal Example: Get Executed Batch IDs

Source: https://docs.sepasoft.com/articles/user-manual/getexecutedbatchids

A simple example to fetch executed batch IDs. This snippet shows the most basic invocation of the function.

```python
ids = system.mes.batch.queue.getExecutedBatchIDs()
```

--------------------------------

### On-the-Fly Supplemental Equipment Example

Source: https://docs.sepasoft.com/articles/knowledge-base/creating-material-and-supplemental-equipment-through-scripting-3-0

This script demonstrates creating a single supplemental equipment object dynamically. It sets the equipment's name, configures its lot handling mode to 'Single Lot', and assigns it to a parent Equipment Class for better organization and searchability.

```Python
##Get the new equipment name from the operator
val = '00001'
 
##Get the parent object for the new equipment object	
parent = system.mes.loadMESObject('Product Bins', 'EquipmentClass')

##Create new equipment object
obj = system.mes.createMESObject('Equipment')

##Set the name
obj.setPropertyValue('Name', val)

##Set the lot handling mode to "Single Lot"
prop = 'Single Lot'
obj.setPropertyValue('EquipmentLotHandlingMode', prop)

##Add the parent object to the new equipment object
obj.addParent(parent)

##Save the new object to manifest the changes.
system.mes.saveMESObject(obj)



```

--------------------------------

### Complex Example: Create, Configure, and Update SPC Sample

Source: https://docs.sepasoft.com/articles/user-manual/system-mes-spc-sample-getnewbydefname-defname-locationpath

Illustrates creating an SPC sample, setting reference number, product code, and a specific attribute value, then updating the sample. Includes error handling for sample creation failure.

```Python
defName = "Finished Good Weight"
locationPath = "Enterprise\Site\Area\Line 1"

sample = system.mes.spc.sample.getNewByDefName(defName, locationPath)

if sample is None:
	raise ValueError("Unable to create the requested SPC sample.")

sample.setRefNo("WO-100145")
sample.setProductCode("FG-100")
sample.getSampleData(1, "Weight").setAttrValue(12.4)

system.mes.spc.sample.update(sample, True)
```

--------------------------------

### Example Output of Get Limit Name List

Source: https://docs.sepasoft.com/articles/user-manual/get-limit-name-list

This is an example of the data structure returned by the getLimitNameList() function, showing various control limit types.

```text
[Box and Whisker LCL, Box and Whisker UCL, c LCL, c UCL, Cp LSL, Cp Target, 
Cp USL, CpPp LSL, CpPp Target, CpPp USL, Histogram LCL, Histogram UCL, Individual LCL, 
Individual UCL, Median LCL, Median UCL, MR LCL, MR UCL, np LCL, np UCL, p LCL, p UCL, Pp LSL, 
Pp Target, Pp USL, Range LCL, Range UCL, StdDev LCL, StdDev UCL, u LCL, u UCL, XBar LCL, 
XBar LSL, XBar UCL, XBar USL]
```

--------------------------------

### Minimal Example: Create and Initialize SPC Sample

Source: https://docs.sepasoft.com/articles/user-manual/system-mes-spc-sample-getnewbydefname-defname-locationpath

Demonstrates the basic usage of getNewByDefName to create a new sample and set initial values for its attributes.

```Python
sample = system.mes.spc.sample.getNewByDefName(
	"Finished Good Weight",
	"Enterprise\Site\Area\Line 1"
)
```

--------------------------------

### Example Execution of Analysis Functions

Source: https://docs.sepasoft.com/articles/knowledge-base/retrieve-equipment-state-counts-from-analysis-3-0

Demonstrates how to call the createAnalysis and runAnalysis functions in sequence to retrieve equipment state counts. Ensure the analysis is created before running it.

```python
savedSettingsName = 'Machine States'
eqPath = 'Enterprise\Site 1\OEE Area\Packaging Line 1'
startDate = system.date.addDays(system.date.now(),-1)
endDate = system.date.now()

createAnalysis(savedSettingsName)
ds = runAnalysis(savedSettingsName, eqPath, startDate, endDate)



```

--------------------------------

### Calling beginNext() Function

Source: https://docs.sepasoft.com/articles/user-manual/mes-schedule-selector

Example of how to call the beginNext() script function on the MES Schedule Selector component. This function starts the next scheduled operation based on its start time.

```Python
event.source.parent.getComponent('MES Schedule Selector').beginNext()
```

--------------------------------

### Minimal Example: Create and Save Signature Template

Source: https://docs.sepasoft.com/articles/user-manual/system-mes-createsignaturetemplate-name

This minimal example demonstrates how to create a new signature template and then save it. It's useful for basic template creation workflows.

```python
template = system.mes.signature.createSignatureTemplate("My New Approval")
saved = system.mes.signature.saveSignatureTemplate(template)
```

--------------------------------

### Get Batch BOM Example

Source: https://docs.sepasoft.com/articles/user-manual/getrecipebom

This example shows the structure of the data returned by the system.mes.batch.queue.getBatchBOM function, illustrating material lot status, target quantity, and other parameters for different process steps like 'Cook'.

```json
{
                                "DataType": "MATERIAL_LOT_STATUS",
                                "Name": "Flavor.Lot_Status",
                                "Value": "Good"
                            },
                            {
                                "DataType": "MATERIAL_TARGET_QUANTITY",
                                "Name": "Flavor.Target_Quantity",
                                "Value": 10
			      "UOM": "Lbs"
                            },
		  //Other Material_Out sub-parameters may be included
                        ],
                    },
                ]
            },
        },
        {
            "Step": "Cook",
            "Phase": "Unit Procedure",
            "Sublogic": {
                "Steps": [
                    {
                        "Phase": "Full Cook",
                        "Step": "Cook",
                        "Parameters": [
                            {
                                "DataType": "DOUBLE",
                                "Name": "Cook_Temperature",
                                "Value": 220.0,
			      "UOM": 
                            },
                            {
                                "DataType": "INTEGER",
                                "Name": "Cook_Time",
                                "Value": 120,
			      "UOM": "Minutes"
                            },
                            {
                                "DataType": "MATERIAL_LOT_NUM",
                                "Name": "Raw_In.Lot_No",
                                "Value": "Raw1234"
                            },
		  {
                                "DataType": "MATERIAL_NAME",
                                "Name": "Raw_In.Material_Name",
                                "Value": "Uncooked Chicken"
                            },
		  {
                                "DataType": "MATERIAL_LOT_STATUS",
                                "Name": "Raw_In.Lot_Status",
                                "Value": "Uncooked"
                            },
                            {
                                "DataType": "MATERIAL_TARGET_QUANTITY",
                                "Name": "Raw_In.Target_Quantity",
                                "Value": 1000,
			      "UOM": "Lbs"
                            },
		  //Other Material_In sub-parameters may be included
		  {
                                "DataType": "MATERIAL_LOT_NUM",
                                "Name": "Cooked_Out.Lot_No",
                                "Value": "Cooked1234"
                            },
		  {
                                "DataType": "MATERIAL_NAME",
                                "Name": "Cooked_Out.Material_Name",
```

```

--------------------------------

### Configure and Execute Analysis with Settings

Source: https://docs.sepasoft.com/articles/user-manual/system-mes-analysis-createmesanalysissettings

Shows how to create an analysis setting, define data points, parameters, filter expressions, and group-by clauses, then execute the analysis with specific parameters and date ranges.

```Python
analysis_setting = system.mes.analysis.createMESAnalysisSettings("test_setting")
datapoints = [
            "Elapsed Time", 
            "OEE Availability", 
            "Runtime", 
            "Planned Downtime", 
            "Infeed Standard Count",
            "OEE Performance",
            "OEE Infeed Count",
            "OEE Quality",
            "OEE Reject Count",
            "OEE Outfeed Count",
            "Equipment Operation Sequence"
            ]
analy sis_setting.setDataPoints(datapoints)
analy sis_setting.addParameter('path')
analy sis_setting.setFilterExpression("Equipment Path = @path AND Operation UUID != ''")
analy sis_setting.setGroupBy("Equipment Operation Sequence")

start_date = system.date.addWeeks(system.date.now(), -1)
end_date = system.date.now()
params = {'path':'Enterprise\Site\Area\Line 3'}
print system.mes.analysis.executeAnalysis(start_date, end_date, analysis_setting, params).getDataset()
```

--------------------------------

### Get Scheduled Finish Time

Source: https://docs.sepasoft.com/articles/user-manual/Sample

Retrieves the scheduled completion date and time for a sample. For automatic samplings, this value will be None. This example shows how to get the scheduled finish time for a sample defined by its name and location.

```Python
#You pass your location path
locationPath = 'Nuts Unlimited\Folsom\Packaging\Packaging Line 1\Line 1 Quality'
sampleDefName = 'Nut Defects'
sample = system.mes.spc.sample.data.getNewByDefName(sampleDefName, locationPath)
print sample.getScheduledFinish()
```

--------------------------------

### Create and Configure Sample Definition

Source: https://docs.sepasoft.com/articles/mes-module-tutorials/spc-perspective-script-configure-sample-definition-manager

Use this script to create a new Sample Definition, assign attributes, a location, rules, and control limits. It also handles creating a Sample Definition Class if it doesn't exist and associates the definition with it. Ensure the MES object names and attribute names match your requirements.

```Python
# =============================================================================
# ===== Create a Sample Definition Class and a Sample Definition ===============
# ===== then assign Attributes, a Location, Rules and Control Limits ==========
# ===== then update a Location property and an existing Sample Definition =====
# =============================================================================
# Define variables for use in configuring properties later
definition_class_name = 'SPC Tutorial Samples'
interval_name = 'Manual' # or 'Every x Value Changes'
definition_name = 'Dimension Sample B'
attributes = ['Diameter', 'LocationX', 'LocationY']

location_path = self.getSibling("mesObjectSelector").props.selectedMESObject.equipmentPath

rule_names = ['Individual Outside']
limit_names = ['Individual UCL', 'Individual LCL']


try:
    samp_def = system.mes.loadMESObject(definition_name, 'SampleDefinition')

except:

    # Create the Sample Definition and assign core properties
    samp_def = system.mes.createMESObject('SampleDefinition')

    samp_def.setName(definition_name)
    samp_def.setInterval(interval_name)
    # samp_def.setDefaultSampleSize(1) # defaults to 1
    # samp_def.setComingDueMinutes(0.0) # defaults to 0.0
    # samp_def.setOverdueMinutes(0.0) # defaults to 0.0
#   samp_def.setIntervalCount(0.0)
#   samp_def.setIntervalDuration(0.0)
    samp_def.setAutoApprove(True) # defaults to false

    # Add a Location
    samp_loc = samp_def.addLocation(location_path)
    samp_loc.setInterval(interval_name) # NEW !!
    # samp_loc.setTag('Scripted') # Defaults to None
    # samp_loc.setComingDueMinutes(0.0) # Defaults to 0.0
    # samp_loc.setOverdueMinutes(0.0) # Defaults to 0.0
    # samp_loc.setIntervalCount(0.0) # Defaults to 0.0
    # samp_loc.setIntervalDuration(0.0) # Defaults to 0.0
    samp_loc.setAutoApprove(True) # Defaults to False

    # Add an Attribute
    for attribute_name in attributes:
        samp_attr = samp_def.addAttribute(attribute_name)
        samp_attr.setAttributeDataType('REAL') # Defaults to REAL - other options INTEGER, BOOLEAN, INSPECTED_COUNT, NONCONFORMING_COUNT, NONCONFORMITY_COUNT
        samp_attr.setSampleDefaultChart('INDIVIDUAL') # Defaults to NONE - other options XBAR_R, XBAR_S, INDIVIDUAL, MEDIAN, U, C, P, NP, HISTOGRAM, PARETO, CP, PP, PPM, ADT, BOX_AND_WHISKER, CPPP
        samp_attr.setFormat('#0.00')
        # samp_attr.setOrder(0) # Defaults to 0
        # samp_attr.setSampleSize(1) # Defaults to 1
        # samp_attr.setSampleDefaultValue(0) # Defaults to None
        # samp_attr.setSampleMinValue(0) # Defaults to None
        # samp_attr.setSampleMaxValue(100) # Defaults to None
        # samp_attr.setUnits('lbs') # Defaults to None
        # samp_attr.setSampleDefaultWeight(1.0) # Defaults to 1.0

    # Assign Rules
    for rule in rule_names:
        samp_def.addRule(rule)

    # Assign Control Limits
    for limit in limit_names:
        samp_def.addLimit(limit)

    # Create a Sample Definition Class
    try:
        samp_def_class = system.mes.loadMESObject(definition_class_name, 'SampleDefinitionClass')
    except:
        samp_def_class = system.mes.createMESObject('SampleDefinitionClass')
        samp_def_class.setName(definition_class_name)

    # Assign the Sample Definition as a child to the Sample Definition Class 
    # (inverse relationship is also created at the same time)
    samp_def_class.addChild(samp_def)

    # Save the Sample Definition and Sample Definition Class objects
    save_list = system.mes.object.list.createList()
    save_list.add(samp_def)
    save_list.add(samp_def_class)
    system.mes.saveMESObjects(save_list)

```

--------------------------------

### Minimal Example: Sync Phases and Save Template

Source: https://docs.sepasoft.com/articles/user-manual/system-mes-batch-recipe-syncphasesandsavetemplate-mesobjectlist

Loads a template, synchronizes its phases, and saves it. Ensure the MESObjectList includes the full template logic graph.

```Python
templateLink = system.mes.batch.recipe.getTemplateLink('My Operation Template')
templateList = system.mes.batch.recipe.loadTemplate(templateLink)
system.mes.batch.recipe.syncPhasesAndSaveTemplate(templateList)
```

--------------------------------

### Get Value of Complex Property

Source: https://docs.sepasoft.com/articles/user-manual/Custom-Properties

Retrieves a specific value associated with a complex property. Returns null if the property or value is not found, without raising an error. This example creates a complex property and then gets a specific value.

```Python
#This code snippet prints the value for the specific property.
seg = system.mes.createMESObject('ProcessSegment')
#Create a new material reference complex property
materialProp = seg.createComplexProperty('Material', 'Vinegar')
print(materialProp.getValue('MaterialProductionSelectable'))
```

--------------------------------

### Create New Sample Definition Object

Source: https://docs.sepasoft.com/articles/user-manual/adding-sample-definitions-via-scripting

Initializes a new, empty sample definition object. Use this as a starting point before setting its properties.

```Python
sd = system.mes.spc.definition.getSampleDefinition('')
```

--------------------------------

### Get Name of Complex Property

Source: https://docs.sepasoft.com/articles/user-manual/Custom-Properties

Retrieves the name of a complex property, which may include extensions for lot references. This example shows how to get complex property names within a segment, update material, and then retrieve names again.

```Python
seg = system.mes.createSegment('Receive Steel', '\Enterprise\Site\Area\Unload Station 1', True)
seg.setMaterial('Steel In', '84000', '\Enterprise\Site\Receiving\Steel\QC Holding', 'Lot 84000-1', 100.0)
cnt = seg.getComplexPropertyCount('ResponseMaterial')
for ndx in range(0, cnt):
    prop = seg.getComplexProperty('ResponseMaterial', ndx)
    print(prop.getName())
seg.begin()
seg = system.mes.getActiveSegment('\Enterprise\Site\Area\Unload Station 1', 'Receive Steel')
seg.setMaterial('Steel In', '84001', '\Enterprise\Site\Receiving\Steel\QC Holding', 'Lot 84001-1', 100.0)
seg.update()
seg = system.mes.getActiveSegment('\Enterprise\Site\Area\Unload Station 1', 'Receive Steel')
cnt = seg.getComplexPropertyCount('ResponseMaterial')
for ndx in range(0, cnt):
    prop = seg.getComplexProperty('ResponseMaterial', ndx)
    print(prop.getName())
```

--------------------------------

### Minimal Example: Get Pending Auth Requests

Source: https://docs.sepasoft.com/articles/user-manual/system-mes-object-signature-filter-create

Demonstrates the minimal usage of system.mes.object.signature.filter.create() to obtain a list of pending authentication requests.

```python
authFilter = system.mes.object.signature.filter.create()
pending = system.mes.signature.authorization.getPendingAuthRequests(authFilter)
```

--------------------------------

### Minimal Example for CompleteDocumentStep

Source: https://docs.sepasoft.com/articles/user-manual/system-mes-batch-queue-completedocumentstep-batchqueueentry-path

A minimal example demonstrating how to call completeDocumentStep. Ensure 'entry' is a valid BatchQueueEntry object and the path is correctly formatted.

```python
system.mes.batch.queue.completeDocumentStep(entry, "/{}:SignOff")
```

--------------------------------

### Begin Segment Example

Source: https://docs.sepasoft.com/articles/user-manual/tracking-material-and-operations

Initiates a new MES segment for tracking material. Requires setting the equipment path, creating a segment object, defining material properties, and then calling begin().

```Python
eqPath = 'Nuts Unlimited\Folsom\Receiving\Nut Unloading'
seg = system.mes.createSegment('Unload Nuts', eqPath, True)
seg.setMaterial('Material In', 'Almond Nuts', '[global]\Nuts Unlimited\Folsom\Receiving\Nut Storage Silos\Almond Silo', 'Lot t55', 50)
seg = seg.begin()
```

--------------------------------

### Create MESObjectLink and Get Full MES Object

Source: https://docs.sepasoft.com/articles/user-manual/MES-Object-Link

Example of creating a MESObjectLink for a 'ProcessSegment' and then retrieving the associated full MES object.

```Python
#Example
objLink = system.mes.object.link.create('ProcessSegment', '4c8edc76-d08b-4838-9e3f-562151eecfa0')
print objLink.getMESObject()
```

--------------------------------

### getStartDateParameterName

Source: https://docs.sepasoft.com/articles/user-manual/mes-analysis-settings

Gets the start date parameter name from the MES analysis (report). This is used for filtering analysis data with Ignition report parameters.

```APIDOC
## getStartDateParameterName()

### Description
Gets the start date parameter name from the MES analysis (report).

### Parameters
None

### Returns
* **String** parameterName - The start date parameter defined in the MES analysis.
```

--------------------------------

### begin()

Source: https://docs.sepasoft.com/articles/user-manual/Operations-Response

Begins the operation, allowing its segments to start. Multiple operations and segments can run concurrently on an equipment item.

```APIDOC
## begin()

### Description
Begin the operation which will allow segments to begin. Multiple operations can be running at an equipment item at a time, and multiple segments can run under an operation.

### Method
`begin()`

### Parameters
None

### Returns
`MESOperationsResponse operResponse` - The operation response object is returned.

### Scope
All

### Example
```python
eqPath = '[global]\Dressings Inc\California\Raw Materials\Unload Station 1'

#Get a new operation to be run at the specified equipment path
oper = system.mes.createOperation('Receive Steel', eqPath)

#Begin the operation
oper = oper.begin()
```
```

--------------------------------

### Create Manifest and Manifest Class via Script

Source: https://docs.sepasoft.com/articles/user-manual/manifests

Demonstrates how to programmatically create a Manifest Class and a Manifest object, save them, and then associate them as parent/child.

```Python
#Create a Manifest Class
manifestClass = system.mes.createMESObject('ManifestClass')
manifestClass.setPropertyValue('Name', 'My Scripted Manifest Class')
system.mes.saveMESObject(manifestClass)

#Create a Manifest
manifest = system.mes.createMESObject('Manifest')
manifest.setPropertyValue('Name', 'My Scripted Manifest')
system.mes.saveMESObject(manifest)

#Add the Manifest as a child of the Manifest Class
man = system.mes.loadMESObject('My Scripted Manifest', 'Manifest')
manClass = system.mes.loadMESObject('My Scripted Manifest Class', 'ManifestClass')
manClass.addChild(man)
system.mes.saveMESObject(manClass)

#Alternative: Add the Manifest Class as a parent of the Manifest
#man = system.mes.loadMESObject('My Scripted Manifest', 'Manifest')
#manClass = system.mes.loadMESObject('My Scripted Manifest Class', 'ManifestClass')
#man.addParent(manClass)
#system.mes.saveMESObject(man)
```

--------------------------------

### Get Primary Begin Trigger Property

Source: https://docs.sepasoft.com/articles/user-manual/Operations-Segment

Retrieves the property that triggers the start of the segment. This property holds information about what will initiate the operation segment.

```javascript
getPrimaryBeginTrigger()
```

--------------------------------

### Example: Creating and Managing a Segment with Personnel Assignment

Source: https://docs.sepasoft.com/articles/user-manual/Response-Segment

Demonstrates creating an operation, adding a segment, assigning personnel using setPersonnel, and beginning the segment. This example illustrates a typical workflow for segment initialization and resource allocation.

```Python
eqPath = 'Dressings Inc\California\Raw Materials\Unload Station 1'

#Create and begin a new operation at the specified equipment path
oper = system.mes.createOperation('Receive Steel', eqPath)
oper.begin()

#Create new segment
seg = oper.createSegment('Inspect Steel')

#Assign peronnel resources....
seg.setPersonnel('Inspector', 'Smith, Sue')

#Begin segment
seg.begin()
```

--------------------------------

### Get Currently Executing Segments

Source: https://docs.sepasoft.com/articles/user-manual/system-mes-getcurrentsegments

This example demonstrates how to use system.mes.getCurrentSegments to retrieve the currently executing response segments for a specific equipment path.

```python
#This example will return the currently executing segments
segCurrent = system.mes.getCurrentSegments('Dressings Inc\California\Raw Materials\Unload Station 1')
```

--------------------------------

### Create and Configure a Document Phase

Source: https://docs.sepasoft.com/articles/user-manual/system-mes-batch-phase-getclasslink-name

This script demonstrates how to create a new document phase, assign it a user-defined string parameter, and add an HTML artifact. It utilizes system.mes.batch.phase.getPhaseLink to get a default phase, system.mes.batch.phase.getClassLink to reference a phase class, and system.mes.batch.phase.createPhase to instantiate the new phase. Finally, system.mes.batch.phase.savePhase persists the changes.

```Python
phaseName = 'myDocument'

defaultPhaseLink = system.mes.batch.phase.getPhaseLink('Document')

phaseClassName = 'Custom Phases'
phaseClassLink = system.mes.batch.phase.getClassLink(phaseClassName)

phase = system.mes.batch.phase.createPhase(phaseName, defaultPhaseLink, phaseClassLink)

#Add a parameter on the phase. See link to Properties Common to All Phase Properties above.
param = phase.addParameter('aStringParam')
param.setParamKindName('User Phase')
param.setParamDataTypeName('String')
param.setParamValueSourceName('Recipe and Execution')
param.setParamRecordingTypeName('All to Object and History')
param.setParamValue('testvalue')

#for document phases there is an artifact
phase.createArtifact('documenttext','<html>Hello World!</html>')

system.mes.batch.phase.savePhase(phase)
```

--------------------------------

### Create and Get MES Object UUID List

Source: https://docs.sepasoft.com/articles/user-manual/MES-Object-Filter

Demonstrates how to create a MESObjectFilter and retrieve its UUID list. An example UUID is added to the list.

```Python
filter = system.mes.object.filter.createFilter()
#Gets the list of uuid.
list = filter.getMESObjectUUIDList()
#Addind another item to the list.
list.add('5253ccae-47b4-4dc2-954f-900ffa8636eb')
```

--------------------------------

### Get Executed Batch IDs

Source: https://docs.sepasoft.com/articles/user-manual/getexecutedbatchids

Retrieves a list of all executed batch IDs without any filters. This is a minimal example demonstrating the basic function call.

```python
system.mes.batch.queue.getExecutedBatchIDs()
```

--------------------------------

### Example Document HTML Output with Values

Source: https://docs.sepasoft.com/articles/user-manual/system-mes-batch-queue-getstepdocument-batchid-documentsteppath

Shows an example of HTML document content returned by getStepDocument, populated with sample parameter values.

```HTML
<div>
	<p>
		This is a document with parameters.
		<br><br>
		String	
		<input type="text" name="Param_String" value="Test String">
			
		<br><br>
		Integer	
		<input type="number" name="Param_Int" value="12.5">
			
	</p>
</div>
```

--------------------------------

### Get COMMAND_START Token

Source: https://docs.sepasoft.com/articles/user-manual/system-mes-batch-queue-command_start

Retrieves the command identifier string for starting a batch. This is useful for ensuring script consistency with the batch runtime's command vocabulary.

```Python
system.mes.batch.queue.COMMAND_START()
```

--------------------------------

### Get Sequence Date of Sample

Source: https://docs.sepasoft.com/articles/user-manual/Sample

Retrieves the start date and time of the shift during which a sample was taken. Requires specifying the sample definition name and location path.

```Python
#You pass your location path
locationPath = 'Nuts Unlimited\Folsom\Packaging\Packaging Line 1\Line 1 Quality'
sampleDefName = 'Nut Defects'
sample = system.mes.spc.sample.data.getNewByDefName(sampleDefName, locationPath)
print sample.getSequenceDate()
```

--------------------------------

### Minimal Example: Copy and Save Signature Template

Source: https://docs.sepasoft.com/articles/user-manual/system-mes-copysignaturetemplate-mesobjectlink

Demonstrates the basic usage of copying an existing signature template and then saving the new copy. Ensure 'sourceLink' is a valid MESObjectLink to a Signature Template.

```Python
# sourceLink is an MESObjectLink to an existing Signature Template.
newTemplate = system.mes.signature.copySignatureTemplate(sourceLink)
savedTemplate = system.mes.signature.saveSignatureTemplate(newTemplate)
```

--------------------------------

### Create and Calculate Sample Finish Time

Source: https://docs.sepasoft.com/articles/user-manual/Sample

Demonstrates how to create a new sample using its UUID and location path, and then calculate its scheduled finish time. Ensure you have the correct sample definition and location path.

```Python
#You pass your location path
locationPath = 'Nuts Unlimited\Folsom\Packaging\Packaging Line 1\Line 1 Quality'
#You pass your sampleUUID
sampleUUID = '716c05dd-ae1c-4ca3-bc0b-ea51226afec3'
sample = system.mes.spc.sample.data.getCreateSampleByName(sampleUUID, '', locationPath)
print sample.calcScheduledFinish()
```

--------------------------------

### Example Output of Default Values

Source: https://docs.sepasoft.com/articles/user-manual/system-recipe-getdefaultvalues

This is an example of the output you might see when calling system.recipe.getDefaultValues. It lists various parameters and their corresponding values, such as Line Speed and Temperature.

```text
Line Speed(1) = 120
IBC Vanilla Percentage = 2.8
Max Temperature = 92
Min Temperature = 85.3
IBC Sugar Percentage = 17.5
Line Speed = 110
```

--------------------------------

### Get Name of Complex Property

Source: https://docs.sepasoft.com/articles/user-manual/complex-property-functions

Retrieves and prints the names of complex properties associated with a segment. This example demonstrates how names are generated with extensions for lot references.

```Python
seg = system.mes.createSegment('Receive Steel', '\Enterprise\Site\Area\Unload Station 1', True)
seg.setMaterial('Steel In', '84000', '\Enterprise\Site\Receiving\Steel\QC Holding', 'Lot 84000-1', 100.0)
cnt = seg.getComplexPropertyCount('ResponseMaterial')
for ndx in range(0, cnt):
  prop = seg.getComplexProperty('ResponseMaterial', ndx)
  print(prop.getName())
seg.begin()
seg = system.mes.getActiveSegment('Enterprise\Site\Area\Unload Station 1', 'Receive Steel')
seg.setMaterial('Steel In', '84001', '\Enterprise\Site\Receiving\Steel\QC Holding', 'Lot 84001-1', 100.0)
seg.update()
seg = system.mes.getActiveSegment('Enterprise\Site\Area\Unload Station 1', 'Receive Steel')
cnt = seg.getComplexPropertyCount('ResponseMaterial')
for ndx in range(0, cnt):
  prop = seg.getComplexProperty('ResponseMaterial', ndx)
  print(prop.getName())
```

--------------------------------

### Begin Operation using MES Operation Selector

Source: https://docs.sepasoft.com/articles/user-manual/tracking-material-and-operations

Shows how to start an MES operation using the MES Operation Selector component via scripting. Requires the selector to be properly configured with the equipment path.

```Python
event.source.parent.getComponent('MES Operation Selector').beginOperation()
```
Tokens:
Raw