system.tag.configure

# This example will retrieve some existing tag configurations, make changes to the configurations, 
# and write the new configurations to the original tags. 


# Define a base path. Sometime useful, but we could hardcode the paths
# in the getConfiguration() and configure() calls.
parentPath = "[NewProvider]SomeFolder"

# Get the current configurations recursively, which is useful when targeting
# folders and UDT Instances.
configs = system.tag.getConfiguration(parentPath + "/AnotherFolder", True)

# The getConfiguration() above always returns a list of dictionaries, and our results
# are inside of the first dictionary. 
for tag in configs[0]['tags']:

	# Check each node. At this point we may get folders or other nodes
	# that we're uninterested in. Examine tagType to figure it out.
    # Note that we're making sure the tagType is in fact a string for this comparison.	
	if str(tag['tagType']) != 'Folder':
		
		# Make a change to the Tag. If we're iterating over UDT instances,
		# then we can change the parameters here. Commented example below:
		# tag['parameters']['myParam'] = foo
		
		# In our case, we'll just disable the Tags.
		tag['enabled'] = False

system.tag.configure(parentPath, configs, "o")

# This example will add a new OPC Tag. It can be further expanded to modify more
# properties on the Tag. Additionally, this example can be used to edit an existing Tag
# by setting the baseTagPath to a Tag that already exists, and by modifying the collision policy.

# The provider and folder the Tag will be placed at.  
baseTagPath = "[default]MyFolder"

# Properties that will be configured on that Tag.
tagName = "myNewTag"
opcItemPath = "ns=1;s=[Simulator]_Meta:Sine/Sine0"
opcServer = "Ignition OPC-UA Server"
valueSource = "opc"
sampleMode = "TagGroup"
tagGroup = "Default"

# Configure the tag.
tag = {
			"name": tagName,			
			"opcItemPath" : opcItemPath,
			"opcServer": opcServer,
			"valueSource": valueSource,
			"sampleMode" : sampleMode,
			"tagGroup" : tagGroup
		}

# Set the collision policy to Abort. Thus, if a Tag already exists at the base path, 
# we will not override the Tag. If you are overwriting an existing Tag, then set this to "o".
collisionPolicy = "a"

# Create the Tag. 
system.tag.configure(baseTagPath, [tag], collisionPolicy)

# The provider and folder the Tag will be placed at.  
baseTagPath = "[default]"

# Create a list of alarms, where each alarm is a Python dictionary. 
alarms = [
			{
				"name":"My scripting alarm",				
				"mode":"AboveValue",				
				"setpointA":10
			}
		]

# Configure the list of Tags. We're only interacting with a single Tag, but still need to pass
# a list as an argument. 
tags = [
			{ 
				"alarms":alarms,
				"name":"myTag"
			}
		]

# Abort if this example attempts to overwrite any of your existing Tags. 
collisionPolicy = "a"

# Create the Tag. 
system.tag.configure(baseTagPath, tags, collisionPolicy)

# This example will add a new UDT Instance. It can be further expanded to modify more
# properties on the Tag. Additionally, this example can be used to edit an existing Tag
# by setting the baseTagPath to a Tag that already exists, and by modifying the collision policy.
 
# The provider and folder the Tag will be placed at.
baseTagPath = "[default]Motors"
 
# Properties that will be configured on that Tag.
tagName = "Motor 1"
typeId = "Motor"
tagType = "UdtInstance"
# Parameters to pass in.
motorNum = "1"
 
# Configure the Tag.
tag = {
            "name": tagName,          
            "typeId" : typeId,
            "tagType" : tagType,
            "parameters" : {
              "motorNum" : motorNum
              }
       }

# Set the collision policy to Abort. That way if a tag already exists at the base path,
# we will not override the Tag. If you are overwriting an existing Tag, then set this to "o".
collisionPolicy = "a"
 
# Create the Tag.
system.tag.configure(baseTagPath, [tag], collisionPolicy) 

# Folders are nodes with a 'tagType' set to 'Folder'.
# Each folder can contain a 'tags' value, which containers other tags and folders. 

Tags={'tagType': 'Folder',
		'name': 'NewFolderName',
		'tags' : [ 
					{ 
					'name': 'anotherfolder',
					'tagType': 'Folder',
					'tags': [{}]			# There aren't any objects defined here, so this will just be an empty folder. 					
					}
				]
		}

system.tag.configure( 	basePath = '',
						tags = Tags,
						collisionPolicy = "o"
					)

# This example configures bindings that make use of three UDT parameters. 
tag = {
  "name": "UDTName",
  "parameters": {
    "device": {
      "dataType": "String",
      "value": "[Sample_Device]"
    },
    "opcPath": {
      "dataType": "String",
      "value": "_Meta:Ramp/Ramp0"
    },
    "opcServer": {
      "dataType": "String",
      "value": "Ignition OPC UA Server"
    }
  },
  "tagType": "UdtType",
  "tags": [
    {
    # Creating a binding involves change the key to an object, with a "bindType" key set to "parameter", and a 
	#  "binding" key set to the binding. Note that the actual binding can consist multiple parameters and characters
      "opcItemPath": {
        "bindType": "parameter",
        "binding": "{device}{opcPath}"
      },
      "opcServer": {
        "bindType": "parameter",
        "binding": "{opcServer}"
      },
      "valueSource": "opc",
      "name": "New Tag",
      "tagType": "AtomicTag"
    }
  ]
}

path = "[default]"
system.tag.configure(path, [tag], "o")