Tcl and Python Environments

When a Tcl script is started, the standard set of Tcl and, if running with the Tk widgets support, Tk variables is available in the interpreter.

In addition, the toolkit provides access to internal toolkit status information via the global array variable ::cactvs in Tcl , or a dictionary with the same name in Python . It is automatically visible both in the top-level interpreter and in slave and thread interpreters. Additionally, the control variables in the language interpreters are linked, i.e. a change made by Tcl is visible in the Python , and vice versa.

Many of the elements in the array may be modified by script commands. If they are manipulated this way, their effects are immediate, but not persistent, and usually visible in all interpreters and, if the value is linked to a core library value, throughout the library for compiled code. The exception are specific elements which are thread-local. Changes to these only modify the seen data to all interpreters in that thread, and library code executing in that thread context.

Parameter changes are forgotten the next time the interpreter is executed.

• cactvs(allowed_read_locations)
  A set of directories which are accessible to the software as data file input locations. If it is an empty set, no directory access check is performed. All toolkit commands which use file I/O perform check their access rights against this list. This option is primarily useful when, for example, allowing a Web tool to execute external script code. Such a feature should then always be combined with a standard safe Tcl interpreter configuration. This is a read-only element. It can be modified by the start-up configuration file.
• cactvs(allowed_write_locations)
  A set of directories which are accessible to the software as data file output locations. If it is an empty set, no directory access check is performed. All toolkit commands which use file I/O perform check their access rights against this list. This option is primarily useful when, for example, allowing a Web tool to execute external script code. Such a feature should then always be combined with a standard safe Tcl interpreter configuration. This is a read-only element. It can be modified by the start-up configuration file.
• cactvs(application)
  Short application name.
• cactvs(application_build_date)
  The build date of the main program or interpreter, in seconds since 1970, suitable for use with clock format .
• cactvs(application_long_name)
  Long name of application.
• cactvs(application_mode)
  A code for the type of application context the Tcl interpreter is operating in. Possible values are 0 (undefined), 1 (simple standalone executable), 2 (executable running encapsulated Tcl script), 3 (full interactive interpreter), 4 (restricted interactive interpreter), 5 (full interpreter running command script), 6 (restricted interpreter running command script), 7 (link library for 3rd party application), 8 ( Tcl module for 3rd party Tcl interpreter), 9 ( Tcl module for Tcl Web browser plug-in), 10 ( Python module with secondary Tcl partner interpreter for 3rd party Python interpreter) or 11 (database UDF module).
• cactvs(aromaticity_model)
  The aromaticity model to use. Possible values are cactvs (the default), daylight (which has some nasty problems, but using it will improve compatibility of the results of Smarts matching with Daylight software, and tripos, for a really weird and not very useful system.
• cactvs(async_computation_receiver_port)
  Port number used for asynchronous networked property computation requests.
• cactvs(auto_container_creation)
  If set, wrapper containers implied by property data retrieval statements on potential container element objects are automatically created. By default, such a data query fails if the container does not yet exist. Examples are the retrieval of reaction property data from an ensemble (if the ensemble is not yet part of a reaction, a reaction is created, and the ensemble becomes the reagent component), or dataset property data from any object which could be a dataset element (ensembles, reactions, tables, networks, but not datasets themselves, here the query accesses the data content of the original dataset).
• cactvs(auto_exit_timeout)
  The spent CPU time in milliseconds after the program automatically terminates. If the value is zero, no timer is set.
• cactvs(auto_vector_extension)
  A boolean flag which controls the behavior of the toolkit when individual elements of vector property data are set with an element index that is larger than the current size of the vector. By default, only existing vector indices ( 0 to $size-1 ) and the new element just beyond current vector size ( $size ) may be used. If the flag is set, any vector index may be addressed. Missing vector elements between the newly set element and the current vector size are filled with default values.
• cactvs(auxdatapath)
  Search path for auxiliary data files required by computational modules.
• cactvs(base_os)
  The operating system core version, i.e. something like Linux 2.6 or Linux3.11 for Linux distributions. This is a read-only string.
• cactvs(biologics_count)
  The current number of biologics objects in memory. This is a read-only attribute.
• cactvs(biologics_table)
  The handle of the table with biologics fragment expansion data (usually this is table3 ). This attribute is read-only.
• cactvs(biologics_support)
  Read-only boolean flag indicating whether this toolkit version has been compiled with biologics object support.
• cactvs(bmp_support)
  Read-only boolean flag indicating whether this toolkit version support image generation in various legacy Windows bitmap formats.
• cactvs(bunzip2_program)
  The fully resolved path name of the bunzip2 program used for I/O of bz2-compressed files.
• cactvs(byte_order)
  A read-only element informing about the byte order of the current platform. It is set to to either littleendian or bigendian .
• cactvs(cache_lifetime)
  Cactvs maintains a cache in the user‘s home directory to cache files obtained from databases and Internet URL s. This parameter defines the lifetime of objects in the cache in seconds. Older files are ignored and searched again via their type-specific standard search path.
• c actvs(captcha_image_file)
  The name of the file with last Captcha image received as result of an attempt to contact an Internet service. This can happen for example when up- or downloading a Google Docs spreadsheet table file. If no such file exists, the element is an empty string. The file is also deleted and the variable is reset when a decoded Captcha was successfully used for log-in.
• cactvs(captcha_string)
  The decoded contents of the Captcha image file above. Its contents are used when attempting to access protected Internet sites. This variable must be set with user interaction. By default, it is a NULL string.
• cactvs(captcha_token)
  The access token associated with the Captcha image file and decoded string. This is used as credential for Internet service log-ins. The variable is typically set together with the Captcha image file when a service requires additional authentication. Scripts would then present the image, get the user to decode it, store the decoded string in the cactvs(captcha_string) variable and then attempt another log-in. Modules which support Captcha log-ins automatically read and set the Captcha variables in the course of their operation.
• cactvs(cmdxpath)
  Search path for Tcl command extension modules. The standard Tcl package path is automatically added to this search path. The main difference between a Cactvs Tcl expansion and a standard Tcl package is the presence of a descriptor structure with metadata. Cactvs Tcl extensions may be loaded as normal Tcl packages, but then do not provide access to the module description data via the cmdx command.
• cactvs(color_support)
  A read-only boolean flag indicating if the decoding of named colors is supported, either by access to a local X11 color names database or by a compiled-in database.
• cactvs(compatible_os_variants)
  Read-only regular expression used to match compatible OS variants for dynamically loading modules.
• cactvs(compress_support)
  A read-only boolean flag indicating that the processing of compressed data is supported. This includes zlib and gzip compression and on most platforms bzip2 . Internally, some data file formats use the lzo compression format.
• cactvs(connect_timeout)
  The maximum number of seconds to wait and, if necessary, retry after a short break in the process of establishing a socket connection. If set to zero, only a single connection attempt is made. Setting it to a negative value configures an unlimited number of connection attempts - but then a command trying to connect to a dead service never returns.
• cactvs(corina_support)
  A boolean read-only flag indicating whether the application was build with an integrated CORINA module for computing atomic 3D coordinates ( A_XYZ , A_CONFORMER ). CORINA support is limited to special toolkit editions and not contained in normal academic or commercial toolkit packages.
• cactvs(cpu_limit)
  A read-only variable describing any hard CPU execution time limits set for the interpreter. If the value is -1, which is the default, no limits have been set. Setting a CPU limit is only supported for specific interpreters on certain platforms (for example, tclcactvs on Linux), and limits must be set at start-up (option -C for tclcactvs ).
• cactvs(crypt_support)
  A read-only boolean flag indicating whether the application support encryption by the crypt (and other) algorithms.
• cactvs(currency_converter_host)
  The default currency exchange rate host. If set to an empty string, Internet-based currency conversion is disabled. Conversion is automatically run if a monetary value is requested in a different currency from the one the data is stored in, and the exchange rate has not yet been cached. Example:

ens set $eh E_PRICE “100.50 EUR”

ens get $eh E_PRICE(USD)

• cactvs(custom_config_file)
  The name of a custom toolkit configuration file specified as command line argument. It is an empty string if no such file was set. The value is read-only.
• cactvs(custom_python_attributes)
  A modifyable value which determines whether Python wrapper objects of core toolkit objects may store additional custom attributes, in addition to the standard toolkit-implemented attributes. By default this flag is not set in order to catch errors in the naming of attributes. If set, any attribute that is not a standard attribute is stored in a private object dictionary, without rasing an error.
• cactvs(data_directory)
  The name of the installation directory which contains - mostly in well-known subdirectories - script libraries, loadable modules, filters, property definitions, images, help files and other auxiliary files needed for the proper operation of the toolkit. The stand-alone interpreter csweb (and its variants) are the only toolkit applications which do not access this resource.
• cactvs(database_file_key)
  An integer indicating that for access to data files a suitable file key must be present. The default value is zero, meaning that no such key is needed. This is only used in very special circumstances when a Cactvs library was built to allow operation only on specifically named files.
• cactvs(database_log_file)
  The name of a file to write logging information for database accesses to.
• cactvs(database_log_mode)
  An boolean value indicating the current log mode. Disabled logging is represented by value 0.
• cactvs(databasepath)
  Search path for database connector modules.
• cactvs(dataset_count)
  The current number of dataset objects. Note that not all datasets necessarily have Tcl handles or Python wrapper objects, so there may be a discrepancy between this value and the result list length of the dataset list command.
• cactvs(dataset_swap_threshold)
  Maximum size of datasets before disk swapping of contained objects is automatically performed. The default value is 10000. A negative value disables automatic disk swapping.
• cactvs(datatool_program)
  The name or, if not found in a standard location, fully specified path of the NCBI datatool program. This program is needed to process PubChem ASN.1 data in text format. For binary ASN.1 data, this program is not used.
• cactvs(db_support)
  A read-only boolean flag indicating whether this interpreter supports database access functions and loadable database client modules ( dbase and dbx Tcl commands).
• cactvs(default_aws_acl)
  The default file ACL for newly uploaded AWS files. A null value means it is unset.
• cactvs(default_aws_key)
  The default public key string for accessing AWS bucket store as identified user. A null value means it is unset.
• cactvs(default_aws_region)
  The default region for newly uploaded AWS files. A null value means it is unset.
• cactvs(default_aws_secret)
  The default local secret for encrypting access parameters for the AWS bucket store. A null value means it is unset.
• cactvs(default_currency)
  The default currency, which is implicitly assumed when dealing with currency data without an explicit currency indicator. The string should be set to the standard international trade name of the selected currency (i.e. EUR, USD, JPY) though a couple of colloquial names are also recognized (Euro, US$, Yen). In any case, a maximum of four characters are significant.

The attribute is thread-local. Changing it has sets the default for future threads only if the modification is performed in the base thread, otherwise these inherit the current setting in the base thread.

• cactvs(default_database)
  Name of the default database. These default values are used to initialize dbx database interface objects and do not directly influence operation.
• cactvs(default_database_host)
  Default database host.
• cactvs(default_database_options)
  Default database options to use in the connection string. The format is database-dependent.
• cactvs(default_database_password)
  Default database access password.
• cactvs(default_database_type)
  Type of the default database connector ( mysql , oracle , etc.), normally mysql .
• cactvs(default_database_user)
  Default database user.
• cactvs(default_element_count_property)
  The property used by default for getting element counts for formula matching, usually E_ELEMENT_COUNT .
• cactvs(default_http_agent)
  The default agent string sent to Web sites when using http-based communication. By default, it uses the string of a reasonably modern Firefox browser.
• cactvs(default_hydrogen_addition_mode)
  The default hydrogen processing mode for file objects. Possible values are asis , add , strip , stripall , and addblind . More information can be found in the documentation of the molfile set command in the section describing the hydrogens attribute.
• cactvs(default_license)
  The default license class for newly created objects which have a license class field. It can be one of xemistry, gpl2, gpl3, lgpl, apache, creativecommons, publicdomain, proprietory, confidential, classified or usgovwork. For commercial toolkit versions, the default is proprietary, and for US government clients usgovwork .
• cactvs(default_reaction_isotope_hash_property)
  The default property for isotope- but not stereo-specific reaction hash codes (usually X_ISOTOPE_HASH128 )
• cactvs(default_reaction_isotope_stereo_hash_property)
  The default property for stereo- but not isotope-specific reaction hash codes (usually X_ISOTOPE_STEREO_HASH128 )
• cactvs(default_reaction_simpleo_hash_property)
  The default property for stereo- and isotope-specific reaction hash codes (usually X_HASH128 )
• cactvs(default_reaction_stereo_hash_property)
  The default property for stereo- but not isotope-ignorant reaction hash codes (usually X_STEREO_HASH128 )
• cactvs(default_reaction_screen_property)
  The default property to use for reaction query screening. This is typically X_SCREEN .
• cactvs(default_similarity_property)
  The default property to use for similarity queries. This is typically E_SCREEN .
• cactvs(default_spinach_formula)
  Thew default formula for matching EliLilly-inspired spinach-class query superatoms indicating a small structural decoration. The initial value is ">=C0-2[Het]0-2", i.e. zero to two carbons, zero to two hetero atoms, no hydrogen specification. Larger substituents do not qualify as spinach.
• cactvs(default_structure_isotope_hash_property)
  The default property for isotope- but not stereo-specific ensemble hash codes (usually E_ISOTOPE_HASH128 )
• cactvs(default_structure_isotope_stereo_hash_property)
  The default property for stereo- but not isotope-specific ensemble hash codes (usually E_ISOTOPE_STEREO_HASH128 )
• cactvs(default_structure_simpleo_hash_property)
  The default property for stereo- and isotope-specific ensemble hash codes (usually E_HASH128 )
• cactvs(default_structure_stereo_hash_property)
  The default property for stereo- but not isotope-ignorant ensemble hash codes (usually E_STEREO_HASH128 )
• cactvs(default_substructure_screen_property)
  The default property to use for substructure query screening. This is typically either E_SCREEN or E_QUERY_SCREEN .
• cactvs(default_superstructure_screen_property)
  The default property to use for superstructure query screening. This is typically either E_NO_HYDROGEN_SCREEN or E_NO_HYDROGEN_QUERY_SCREEN .
• cactvs(default_system_encoding)
  The character encoding used by the environment. It is typically UTF-8 or ISO8859-1
• cactvs(default_tauto_hash_property)
  The standard tautomer structure hash property (usually E_TAUTO_HASH128 )
• cactvs(default_warmup_reaction)
  A line encoding of the default reaction to use with the prop use command if a property does not have its own specific computation warm-up reaction definitions.
• cactvs(default_warmup_structure)
  A line encoding of the default structure to use with the prop use command if a property does not have its own specific computation warm-up structures. The standard structure contains aliphatic and aromatic rings, multi-ring ringsystems, atom and bond stereochemistry, aromatic and aliphatic pi systems, an isotope label and other structural attributes which might play a role in property computation.
• cactvs(dependency_warning)
  If set, warn about property dependencies detected when parsing a property definition which involves dependent properties which are not yet defined. Having such dependencies is not illegal, and the dependencies are updated at a later time when the unresolved, referred property has been set up. However, in case these properties are never read, dangling dependencies are never resolved and ignored, and this may indicate a programming error.
• cactvs(disable_io_modules)
  If set to 1, no file format extension modules are loaded, even if they are listed in the local system configuration file for automatic loading. Also, automatic look-up for extension modules on file suffixes is blocked.
• cactvs(disable_toolkit_rpc)
  If this flag is set, RPC communication with other Cactvs applications is disabled. Since the Windows port currently does not support RPC inter-process communication, this flag has no effect on that platform. This flag only applies only to internal RPC between toolkit applications, not to operating the interpreter as KNIME RPC server.
• cactvs(distribution)
  The platform this package was compiled for, including distribution information. Example: Linux2.6-SuSE10.2-64. This element is read-only.
• cactvs(do_database_lookup)
  If set, look-up of extension modules in databases is enabled.
• cactvs(do_signals)
  If set (which is the default), untrusted or flaky property computation modules may be executed with a set of signal handlers in place, which try to recover from segmentation fault errors and other signals. Recovery is not guaranteed to work if the module corrupted working memory. The signal handler overhead is not insignificant, and properties should be configured to rely on installed signal handlers only if required, and where the problem is not fixable, for example because the source code is not available.
• cactvs(do_timeouts)
  If set, allow time-outs in property computations to occur. This flag is on by default.
• cactvs(dynamic_loader_mode)
  If this flag is to a positive value (it is set by default), the toolkit allows the loading of dynamic extension modules of all supported classes if not prohibited by class-specific flags. Specifically, a value of one allows loading of modules found in the trusted path, a value of two loading from both the standard and trusted path, with the trusted path having preference, and a value of three again loading from both paths, but the the standard path having preference.
• cactvs(element_sequence)
  A list of the numbers of the elements of the periodic system in standard Hill formula sequence (6 = carbon, 1=hydrogen, 0 = pseudo-atoms, 89= Actinium, and so forth).
• cactvs(element_table)
  The handle of the table with element data (usually this is table0 ). This attribute is read-only.
• cactvs(ens_count)
  The current number of ensemble objects. Note that not all ensembles necessarily have Tcl handles or Python wrapper objects, so there may be a discrepancy between this value and the result list length of the ens list command.
• cactvs(eol_chars)
  The platform-dependent default end-of-line character(s).
• cactvs(eutils_contact)
  The contact email to include in NCBI Eutils queries. By default, it is a generic xemistry.com address.
• cactvs(eutils_host)
  The name of the host with the NCBI Eutils suite of Entrez database access services. If set to an empty string, Entrez access is disabled. Setting it to a different host is only useful if you run an Entrez clone in-house. The default is eutils.ncbi.nlm.nih.gov.
• cactvs(eutils_toolname)
  The tool name to report when submitting NCBI Eutils queries. The default is CactvsToolkit .
• cactvs(executable_type)
  The platform model the executable was compiled for. It is either 32 or 64 bits. This information is read-only.
• cactvs(executablepath)
  Search path for executable external programs, such as compressors and decompressors, which in some circumstances are automatically launched for I/O operations.
• cactvs(explicit_stereo_h)
  A global formatting flag used by various property computation routines and file I/O modules which indicates preference to retain hydrogens at stereo centers for maximum interpretation reliability, or whether to strip them and to rely on the proper re-attachment by a reader or decoder. By default this flag is set, i.e. stereo hydrogen is preferentially retained.
• cactvs(expr_support)
  A read-only boolean flag which indicates whether the application supports SQL -style expressions on data attached to objects, for example via the expr object commands.
• cactvs(extension_support)
  A read-only boolean flag which indicates whether this interpreter is capable of loading extension modules, for example file I/O format handlers or datatype handler modules.
• cactvs(external_colordb)
  If set, the software tries to preferably access a locally installed X11 color database, overriding the built-in color collection. The internal color set is used as fall-back is the flag is not set, or no X11 color database can be found.
• cactvs(extra_format_flags)
  A list of the names of extra formatting bits which should be used for property data formatting in the interpreter. By default this is an empty list.
• cactvs(fcgi_redirect)
  This read-only boolean variable is an indicator on whether the stdout , stderr and stdin standard I/O channels are currently redirected to the corresponding FCGI channels. To activate or cancel redirection, use the fcgi Tcl command, which is available in some interpreter versions ( tclcactvs , csweb ).
• c actvs(fcgi_support)
  A read-only boolean flag indicating whether this application was compiled with FCGI (fast CGI ) support. This flag informs about the availability of the fcgi script command as well as the ability of various output mechanisms to directly stream into an FCGI channel, or a standard channel redirected into a FCGI channel.
• cactvs(filexpath)
  The search path for structure and reaction file I/O module extensions
• cactvs(filterpath)
  The search path for filter definitions.
• cactvs(fontpath)
  The search path for TrueType fonts used by several imaging modules.
• cactvs(full_smarts_support)
  A read-only boolean flag indicating whether this interpreter was compiled with a full SMARTS parser. SMILES and some basic SMARTS (essentially the flat match attribute level as found in query Molfiles ) can be processed even if this capability was not added.
• cactvs(gdbm_support)
  A read-only boolean flag indicating whether this interpreter was compiled with GDBM key/value store support.
• cactvs(gunzip_program)
  The fully resolved path name of the gunzip program used for I/O of gzip -compressed files. An external decoder is only forked if the file is a simple file, and might contain formatting features which cannot be resolved by the simple zlib-based internal program emulation.
• cactvs(gzip_program)
  The fully resolved path name of the gzip program used for I/O of gzip -compressed files. An external decoder is only forked if the file is a simple file, and might contain formatting features which cannot be resolved by the simple zlib-based internal program emulation.
• cactvs(host)
  The name of the computer the interpreter is running on. Read only.
• cactvs(host_domain)
  Domain name of the host. This is often not automatically identifiable, but can be set by scripts.
• cactvs(host_ip)
  The IP address of the computer the interpreter is running on. Read-only. Depending on the number of network interfaces detected, additional read-only entries named host_ip2 etc. may be present, including IP address 127.0.0.1 for localhost .
• c actvs(https_enforcement)
  If set, use https instead of http for external communication where possible.
• cactvs(iconv_program)
  The fully resolved path name of the iconv program used for I/O of files encoded in UCS-2 and other non-Latin1 encodings of text data.
• cactvs(inchi_support)
  A read-only boolean flag indicating whether this interpreter supports operations with InChI strings, including decoding of such strings in the ens create command, computing the E_INCHI, E_STDINCHI, E_INCHIKEY and E_STDINCHIKEY properties, and I/O support for InChI files with or without auxiliary data.
• cactvs(internet_lookup_level)
  This element controls the extent to which Internet-based operations can be implicitly executed. If set to level 0, no external Internet communication takes place. Level one enables the use of Internet services in computational modules and file I/O modules. They are still subject to fine-grained control from the settings of the host control variables and the structure security flag. Level 2 additionally enables the lookup of property definitions and extension modules in Internet repositories named in the search paths. The default Internet lookup level is one.
• cactvs(internet_support)
  A read-only boolean flag informing whether this interpreter was compiled with support for accessing Internet resources, for example via URL s or SOAP messages.
• cactvs(interrupted)
  A thread-local flag set when an interrupt (user pressing ctrl-c, time-out of operation with time limit) occurred. Commands which can be interrupted reset the variable to 0 when the command execution begins. Examples: The molfile scan and ens transform commands.
• cactvs(io_support)
  A read-only boolean flag indicating whether this interpreter supports file-based chemistry data I/O. This flag is only unset in a few specialized link libraries where chemistry data is directly stored in the internal data structures by a third-party application program.
• cactvs(is_slave)
  A read-only boolean flag indicating whether this interpreter is a slave interpreter (for example, a property computation interpreter for scripted properties) or not. Thread main interpreters are not slaves.
• cactvs(itcl_support)
  A read-only boolean flag indicating whether the Itcl Tcl object-oriented programming extension commands are available in this interpreter as a compiled-in component. If not, the Itcl module may still be loaded with standard Tcl load or package commands.
• cactvs(java_class_path)
  The Java VM class path, if this is an executable which also has a Java VM compiled in.
• cactvs(java_error_message)
  The last error message generated by a Java tool.
• cactvs(json_support)
  A read-only boolean flag indicating whether the application was compiled with an integrated JSON parser. This flag informs about the availability of the json script command, and support for various json-based encoding and decoding schemes, for example for table data I/O.
• cactvs(keyxpath)
  The database key extension module search path.
• cactvs(kill_object_limit)
  The maximum number of toolkit objects to be present in memory at any time before the program auto-terminates in order to avoid memory hogging. This is primarily a safety feature to prevent scripts which leak objects from wrecking havoc. A negative value indicates that no limit is enforced.
• cactvs(knimenode_deadman_timeout)
  The number of milliseconds a KNIME node function may execute in a single invocation before the application is terminated to protect the server integrity. If this attribute is used, it should be set to a somewhat larger value than the soft node invocation timeout. A value of zero or less disables the deadman timer.
• cactvs(knimenode_debug)
  If set to a true value, KNIME nodes are run in debug mode.
• cactvs(knimenode_default_editurl)
  If compiled with KNIME node support, the URL of an Internet-accessible node editor application such as https://xemistry.com/NodeDesigner.
• cactvs(knimenode_default_host)
  If compiled with KNIME node support, the name of the default RPC host compiled into nodes.
• cactvs(knimenode_default_password)
  If compiled with KNIME node support, the default RPC password. If the program is run as a KNIME node RPC server, this is the password external node users must provide to gain access if no specific user/password combinations are configured.
• cactvs(knimenode_default_port)
  If compiled with KNIME node support, the default RPC port compiled into nodes. The default port is 16570.
• cactvs(knimenode_default_rpc_logfile)
  The name of a file to log the RPC communication between a node server and a KNIME workbench.
• cactvs(knimenode_default_user)
  If compiled with KNIME node support, the name of the default RPC user. If the program is run as a KNIME node RPC server, this is the user name external node users must provide to gain access if no specific user/password combinations are configured.
• cactvs(knimenode_fork)
  If the program is run as KNIME RPC server, and this flag is set, individual KNIME nodes are executed on forked server application instances instead of a shared executable. Nodes which use a Python interpreter are always forked, due to Python multi-threading limitations.
• cactvs(knimenode_max_exectime)
  If the program is run as KNIME RPC server, this is the maximum wall time in seconds allowed to be spent in the execution script per node invocation. If the time is exceeded, the script execution is stopped and an error reported to the workbench.
• cactvs(knimenode_max_file_size)
  If the program is run as KNIME RPC server, this is the maximum size of transferred file blobs (for example, reading upload files which are not accessible on the local file system). A negative value disables the check.
• cactvs(knimenode_max_rows_per_port)
  If the program is run as KNIME RPC server, this is the maximum number of rows accepted or sent per table port per node invocation.
• c actvs(knimenode_max_rows_total)
  If the program is run as KNIME RPC server, this is the maximum number of rows combined over all table-type input and output ports of a node which are accepted and sent per node invocation across all ports.
• cactvs(knimenode_max_statements)
  If the program is run as KNIME RPC server, this is the maximum number of Tcl statements which may be executed per node invocation. If this number is exceeded, script execution is terminated and an error reported.
• cactvs(knimenode_safe_interpreters)
  If set, all KNIME nodes are executed in safe interpreters, which limits the type of script statements they can use.
• cactvs(knimenode_support)
  A read-only flag indicating whether this interpreter was compiled with support for working with KNIME nodes ( knode command).
• cactvs(largefile_support)
  A read-only boolean flag indicating if this version of the library supports 64-bit file operations. There are probably no platforms that are still supported which do not allow operations on files with more then 2 or 4GB.
• cactvs(lhasa_support)
  A read-only boolean flag indicating that the interpreter supports the lhasa object which understands Lhasa reaction transforms and the parsing of Patran and Chmtrn data.
• cactvs(library_compile_date)
  The read-only compilation date of the main toolkit library in seconds since 1970. This value is suitable for use with clock format .
• cactvs(library_compile_flags)
  The C compiler flags used for compiling the main toolkit library. The value is read-only.
• cactvs(library_compiler)
  The compiler which compiled the main toolkit library. The value is read-only.
• cactvs(library_directory)
  The path of the directory where the bundled link libraries for this installation are stored. For stand-alone applications, this element is empty.
• cactvs(library_error_code)
  The numerical error code of the last Cactvs library error of the current thread. Custom errors, for example raised by modules which use a custom message and not the standard message table have an error code of minus one. This is a read-only element, and thread-local.
• cactvs(library_error_message)
  The last raw Cactvs library error message of the current thread, without any formatting for the Tcl interpreter. Most library messages also generate a Tcl error message, but there are many error messages in the toolkit related, for example, to command syntax problems which are part of the scripting layer and not handled by the core library. Such errors do not change the library message. This is a read-only element, and thread-local.
• cactvs(license_comment)
  Comments regarding the license. Read only.
• cactvs(license_developer)
  Name of the developer of an application. Read only.
• cactvs(license_hostname)
  Name of licensed host, empty if not set. Read-only.
• cactvs(license_hostid)
  Host-ID of licensed host, 0 if not set. More elements license_hostid2 to license_hostid10 are present if multiple host IDs are covered by a license. Since academic packages are not bound to host IDs, this array element is not present in such packages. If present, this is a read-only element.
• cactvs(license_ip)
  IP-address for licensed host, 0 if not set. More fields license_ip2 to license_ip10 are provided if multiple IP addressed are covered by a license. Since academic packages are not bound to IP addresses, this array element is not present in such packages. If present, this is a read-only element.
• cactvs(license_maxversion)
  Maximal toolkit version covered by license. 0 if not set.
• cactvs(license_minversion)
  Minimal toolkit version covered by license. 0 if not set.
• cactvs(license_netmask)
  Network mask for license. 0 if not set. Read only.
• cactvs(license_network)
  Network address for license. 0 if not set. Read only.
• cactvs(license_serial)
  Serial number of license. 0 if not set. Read only.
• cactvs(license_support)
  A read-only boolean flag indicating whether this interpreter support license handling.
• cactvs(license_timeout)
  Time-out date for license in standard Unix notation (seconds since 1970). 0 for permanent licenses. Read only. Use the clock format command to convert it into a readable representation.
• cactvs(license_type)
  License type ( commercial , academic , government , evaluation ). Read only.
• cactvs(license_user)
  Licensed host account user name. The element is not present if not set. More elements license_user2 to license_user10 are present if multiple user names are covered by a license. Since academic packages are not bound to users, this array element is not present in such packages. If present, this is a read-only element.
• cactvs(licensee)
  Licensee of the basic toolkit. Read only. This is a free-form string, not a host account name (see above).
• cactvs(licensor)
  Licensor name. Read only.
• cactvs(lookup_hosts)
  A list of the names of the hosts used for lookup operations (such as chemical name and CAS number resolution in the ens create command). The default host list is cactus.nci.nih.gov ( NCI resolver) and opsin.ch.cam.ac.uk (systematic name resolver). www.genome.jp ( KEGG ) and chemspider.com are also supported as an additional resolvers and can be added or replaced if desired .

If this array element is set to an empty string, compound name lookup/resolution is disabled. Operations involving contacting the name lookup hosts are not controlled by the ::cactvs(structure_security) variable setting, because no connection tables are transmitted.

It is possible to attach a directory/file part to the host name for the NCI resolver. If a lookup host is specified in this fashion, the default path ( /chemical/structure/ ) is overridden. This feature allows access to experimental releases of this service.

• cactvs(lookup_mode)
  This array element can be used to fine-tune the operation of the NCI resolver. By default, this element is unset, and the default resolver mode is selected when the resolver host is contacted. One useful supported value is name_pattern , which invokes substring name search on the resolver.
• cactvs(lookup_timeout)
  The thread-local maximum number of seconds to wait for an answer from an Internet-based structure identifier resolver (such as PubChem for CIDs and SIDs, or KEGG for KEGG IDs). A zero value indicates no timeout.
• cactvs(lookup_timeout_occurred)
  This thread-local flag is cleared before the auxiliary Tcl or Python commands fetch or post are executed, or an attempt is made to resolve a structure identifier (see ens create command) by contacting a remote server. If any of these operations fail due to a server timeout, but not other causes, this flag is set and remains set until the next look-up operation is performed, or the flag is explicitly reset in a script.
• cactvs(lzo_support)
  A read-only boolean flag indicating whether the interpreter supports the Lzo compression/decompression scheme. This method can for example be used in Minimol compression, resulting in a somewhat faster decompression compared to standard Zlib .
• cactvs(malloc_bytes)
  Total count of allocated bytes. Only updated when memory debugging is active.
• cactvs(malloc_count)
  Count of memory allocation operations. Only updated when memory debugging is active.
• cactvs(malloc_free)
  Count of memory release operations. Only updated when memory debugging is active.
• cactvs(malloc_total)
  Currently allocated memory byte count. Only updated when memory debugging is active, and only valid on Windows (where you can obtain the original allocation size of a memory block from its address).
• cactvs(max_scan_threads)
  The maximum number of scan threads on a single handle which can concurrently use the library. This is a read-only value. Earlier toolkit versions also had limitations on the maximum numbers of library and Tcl threads - these are now unlimited.
• cactvs(maximum_ring_count)
  The maximum number of rings allowed in an ensemble. This value is primarily intended to act as a safeguard against the processing of structures with insane numbers of rings, as it can happen while decoding overlapping 3D structures, and not as a principal limitation of the toolkit. The default value of 1000 is certainly sufficient even for large proteins.
• cactvs(maximum_ring_size)
  The number of atoms in the largest rings which will be detected. The standard value is 80.
• cactvs(maximum_stereo_distance)
  The maximum number of bonds traversed to check stereogenicity, and, indirectly, compute various stereo descriptors. Ligands which differ only beyond this bond distance are not considered different for the purpose of stereo handling. The default value is 22, which corresponds to the maximum required value to handle all entries in the FDA registry.
• cactvs(memory_limit)
  A read-only variable indicating hard memory consumption limits in bytes which have been set for the application. In case this value is -1, no limits are set, which is the default. Memory limits can only be set for certain interpreter versions (for example, tclcactvs on Linux), and only on start-up (option -M for tclcactvs ).
• cactvs(minimol_support)
  A read-only boolean flag which indicates whether this interpreter has support for Minimols.
• cactvs(mmap_buffer_size)
  The maximum length of the memory map buffer for field-based file I/O, in bytes. This attribute affects only a few file formats which can utilized large memory buffers, most notably the cbs search file format. If the data size of a field exceeds this limit, the data are read by means of traditional file I/O and not consume system memory resources.
• cactvs(mmap_high_threshold)
  Maximum size of files which should use memory mapping for accelerated reading. Note that this limited applies only to full file mapping - file formats with direct access query fields will still map those fields for accelerated access.
• cactvs(mmap_low_threshold)
  Minimum size of files read via memory mapping for accelerated reading.
• cactvs(molecule_bond_set)
  A bit set of those bond types which contribute to grouping atoms into molecules. The default set consists of the bond types normal, dative, complex, ionic and 3center .
• cactvs(molfile_count)
  The number of currently active molfile object handles. Note that not all structure file access objects necessarily have Tcl handles or Python wrapper objects, so there may be a discrepancy between this value and the result list length of the molfile list command.
• cactvs(multithreaded_script_support)
  A read-only boolean flag indicating whether this interpreter supports multi-threaded scripts. This is not equivalent to the thread_support flag. The latter is a prerequisite and indicates that the core library supports multiple threads.
• cactvs(namespace)
  The local URN namespace, which is for example used during property look-up. By default, it is set to .local.
• cactvs(namespacepath)
  The namespace resolution path.
• cactvs(network_count)
  The current number of network objects. Note that not all networks necessarily have Tcl handles or Python wrapper objects, so there may be a discrepancy between this value and the result list length of the network list command.
• cactvs(network_support)
  A read-only boolean flag indicating whether this application was compiled with support for the network object, including its vertex and connection minor objects, plus the associated script commands of the same name.
• cactvs(netxpath)
  The search path for network file I/O modules.
• cactvs(nitrogen_valence_check)
  The default mode for checking nitrogen valences with the ens/mol/atom valencecheck commands. The default is ionic, meaning that pentavalent nitrogen is rejected. The possible values are xionic , ionic , asis , pentavalent and xpentavalent .
• cactvs(object_auto_scope)
  This thread-specific flag controls whether major objects with Tcl handles (ensembles, reactions, datasets, molfiles, tables and networks) which are generated within a thread interpreter or slave interpreter are automatically scoped to that interpreter (see :: cactvs(object_scope)) , meaning that their handle can only be resolved by that interpreter.
• cactvs(object_scope)
  This flag controls whether object handles can be resolved in all Tcl interpreters of an application or can be limited to an interpreter which claims them and hides them from global visibility. By default, all objects with handles are globally resolvable, regardless of their creation mode. The main purpose of this flag is that is allows scripted computation modules to hide objects (such as substructure ensembles) which they set up once and which persist after the computation finishes. Hidden objects still count for the global object counts (such as ::cactvs(ens_count) ), but, for example, no longer appear in ens list executed in a main interpreter when they are created and hidden in a property slave interpreter. This makes the detection of object leaks simpler.
• cactvs(objectpath)
  Search path for compiled objects used by property computation modules, including dynamic shared objects, OSX bundles or Windows DLLs.
• cactvs(ocrhost)
  The host to use when performing chemical structure drawing OCR , for example when reading GIF or PNG files as chemical structure files where these image do not possess hidden embedded structure data. The default host cactvs.nci.nih.gov runs the OSRA service.
• cactvs(online)
  Flag indicating whether the local host has Internet access. Automatically updated.
• cactvs(openphacts_id)
  The application ID for accessing OpenPhacts data.
• cactvs(openphacts_key)
  The key for accessing OpenPhacts data.
• cactvs(os)
  The name of the operating system the interpreter is running on, in the full nomenclature used also to name the toolkit packages, i.e. with the name of the operating system distribution. Read only.
• cactvs(osra_program)
  The name or full path of a local installation of the Osra chemical OCR program. If it is found, it is used in preference to the Web service, which is advantageous in case of confidential data.
• cactvs(overwrite_protection)
  If this flag is set, most toolkit chemistry commands which write files (but not standard Tcl or Python file commands) will refuse to overwrite existing files, even if the file permissions would allow it

This is a thread-local flag. Changing it has an effect for future threads only if the change is performed in the base thread. Otherwise, new threads inherit the current setting of the base thread.

• cactvs(paper_size)
  The default paper size. Usually set to A4 , or Letter , but the standard range of DIN and US sizes is recognized.
• cactvs(persistent_bond_set)
  Bit set of bonds which are persistent, meaning that they are not completely discarded when the structure changes. The default set consists of the bond types normal, dative, ionic, complex, 3center , nobond , and rgroup .
• cactvs(platform)
  Platform information - unix , mac or windows .
• cactvs(preload_datatype_extensions)
  A list of datatype handler extension modules which should be automatically loaded at start-up (as per typex load command). This variable is typically set via a start-up configuration file since modifying it at run-time has no effect.
• cactvs(preload_db_extensions)
  A list of database connector extension modules which should be automatically loaded at start-up (as per dbx load command). This variable is typically set via a start-up configuration file since modifying it at run-time has no effect.
• cactvs(preload_file_extensions)
  A list of structure and reaction I/O extension modules which should be automatically loaded at start-up (as per filex load command). This variable is typically set via a start-up configuration file since modifying it at run-time has no effect.
• cactvs(preload_network_extensions)
  A list of network I/O extension modules which should be automatically loaded at start-up (as per netx load command). This variable is typically set via a start-up configuration file since modifying it at run-time has no effect.
• cactvs(preload_table_extensions)
  A list of table I/O extension modules which should be automatically loaded at start-up (as per tablex load command). This variable is typically set via a start-up configuration file since modifying it at run-time has no effect.
• cactvs(processor_count)
  The number of processor cores seen by the interpreter. There is no distinction between multi-core and multi-die processors. This attribute is read-only.
• cactvs(property_definition_count)
  The number of properties currently registered in the core. This attribute is read-only.
• cactvs(property_lock)
  If set, properties cannot be deleted from the internal property database, and many operations changing the character of a property are also disabled. This is normally only used in multi-threaded scripts where locking the property database can give a significant speed boost because it eliminates the need to look and unlock individual property definitions.
• cactvs(propertypath)
  The search path for property definitions.
• cactvs(proxy_bypass_hosts)
  A comma-separated list of host names which should be contacted directly, not via the proxy host. This variable is only used if a proxy has been configured. The default is an empty list.
• cactvs(proxy_host)
  The name of a proxy server which is used as an indirect Internet access gateway. All standard Internet-access operations will automatically reroute requests via this proxy, if a proxy host is set. If the string is empty, which is the default, direct Internet access without a proxy is used.
• cactvs(proxy_password)
  A password which is supplied to the Internet proxy server, if one has been configured.
• cactvs(proxy_user)
  The username to supply to the Internet proxy server, if one has been configured.
• cactvs(pubchemhost)
  The host name which is used for PubChem-related data retrieval via the PUG interface, or screen scraping of certain information pages. The default is pubchem.ncbi.nlm.nih.gov.
• cactvs(python_error_nessage)
  The last error message generated by a Python interpreter. If the current application does not contain an embedded Python interpreter, this is always an empty string. This attribute is thread-specific (though currently there can only be a single Python thread).
• cactvs(python_object_autodelete)
  This flag controls whether in the Python interface major objects behave like in Tcl , where they are persistent until explicitly deleted, or in standard Python fashion. In the latter style, objects are deleted when their last Python reference goes out of scope and it is not otherwise protected from deletion (such as being property data, or a member of a dataset). Objects which never instantiate a Python reference are never auto-deleted either. For compatibility, the default mode is the Tcl style. In this mode, major chemistry objects are only deleted by explicitly calling their delete() methods, or when used in a with clause. The del command only deletes (more precisely: decrements the reference count of) the associated Python wrapper object, without touching the underlying chemistry object, and variable scope tear-downs have no effect either. If auto-delete is enabled, the deletion of reference objects by the latter two methods also deletes unprotected chemistry objects. delete() and with clauses continue to work as in the Tcl mode.
• cactvs(python_support)
  A boolean read-only flag indicating whether a parallel Python interpreter is available in this application, which can be accessed with the python command, or indirectly by using properties with computation functions written in Python .
• cactvs(qlz_support)
  A read-only boolean read-only attribute indicating whether the object swap system uses the faster QLZ compressor instead of slower ZLIB compression.
• cactvs(reaction_count)
  The current number of reaction objects. Note that not all reactions necessarily have Tcl handles or Python wrapper objects, so there may be a discrepancy between this value and the result list length of the reaction list command.
• cactvs(release_date)
  Release date of the toolkit, in standard Unix format as seconds since 1970, intended for use with the clock format command. Read only.
• cactvs(repository_support)
  A read-only boolean flag indicating whether this interpreter supports repository objects.
• cactvs(repxpath)
  The alternate representation module search path
• cactvs(ring_bond_set)
  Bit set of bond types which define rings in structures. The default set consists of the bond types normal, dative, ionic, complex , and 3center .
• cactvs(ringset)
  The type of ring set computed by default. The default is esssr .
• cactvs(rpc_id)
  ID of the RPC communication protocol between Cactvs processes.
• cactvs(rpc_support)
  A read-only boolean flag indicating whether this application was compiled with support for RPC -based socket-facilitated data exchange between Cactvs applications, for example remote property calculations. This flag only informs about that specific data exchange mechanism. The availability of other socket-based mechanisms (remote datasets, remote query processing, table row data transfer, file access via URL s, etc.) are not covered.
• cactvs(rpc_version)
  The version of toolkit-internal RPC communication protocol.
• cactvs(safe_interpreter)
  A boolean read-only flag. If set, the current interpreter is safe, i.e. has been stripped of potentially dangerous commands.
• cactvs(script)
  The read-only name of the currently executed application script. Empty if no script is run. Depending on the main interpreter type, this is either a Tcl or a Python script.
• cactvs(script_url)
  If the script interpreter executes a script obtained by Internet access via an URL , the URL is listed here. Read only.
• cactvs(secondary_script)
  The read-only name of the secondary application script, i.e. the helper Python script when running a main Tcl script, or the helper Tcl script when running a main Python interpreter. If no such string is used, this is an empty value.
• cactvs(setsize_exceeded)
  A thread-local flag indicating that a command which allows the specification of a maximum number of result objects to create has attempted to exceeded this number. Commands which can be controlled in this manner reset the variable to 0 when the command execution begins. Example: The ens transform command.
• cactvs(smartsmacro_table)
  The handle of the table with SMARTS macro expansion data (usually this is table2 ). This attribute is read-only.
• cactvs(smiles_hypervalent_hydrogen_addition)
  If this flag is set, the addition of implicit hydrogens follows the strict Daylight specification demanding that hydrogens are added until the next standard valence is reached. This means that, for example, an uncharged S(III) or S(V) atom is hydrogenated to S(IV) or S(VI). Chemically, this usually does not make sense, but it can be useful for interoperability testing or porting of legacy Daylight functionality. By default, hydrogens are not added to hypervalent atoms in PSE groups 15 and 16, which makes automatic correction of the structure to much more likely S + (III) and similar species simpler.
• cactvs(smiles_version)
  The version of SMILES / SMARTS to use. Currently, it can be set to 4.9 or 4.3 (or any value below 4.9). The difference is that in version 4.9 the x atom attribute is interpreted according to the newly introduced Daylight definition (number of ring bonds), while before that this letter was unused and interpreted as an Cactvs extension (number of hetero atom ligands). In 4.9 mode, the former x extension is now accessed via the letter z . The default is 4.9, i.e. full support of the most current Daylight definition.
• cactvs(smtp_host)
  The default mail host to use when sending email with the mail command.
• cactvs(smtp_password)
  The password to use when connecting to above mail host.
• cactvs(smtp_port)
  The port to use to connect to the mail host. The default is 587, the newer recommended value both for smtp and smpts transfers. Some mail host may require other ports, such as the old standard 25, or the alternative port 465 for direct smpts without negotiation.
• cactvs(smtp_user)
  The user ID to use when connecting to above mail host.
• cactvs(soap_method)
  Name of default method called via SOAP request.
• cactvs(soap_schema)
  Default SOAP communication schema name.
• cactvs(soap_uri)
  Default URI associated with SOAP communication schema.
• cactvs(source_lookup)
  If this boolean flag is set, the toolkit will attempt to retrieve source code of modules obtained via Internet connections, in addition to the executable format.
• cactvs(sourcepath)
  The search path for source code for extension modules.
• cactvs(sql_dialect)
  The SQL dialect to be used when generating SQL code fragments, such as in a sqlget command. This can be the name of any database connector module, though currently dialect-specific formatting is only used for mysql , postgresql and sqlite .
• cactvs(ssl_client_cert_file)
  The name of the SSL client certificate file if one was specified at start-up.
• cactvs(ssl_server_cert_file)
  The name of the SSL server certificate file if one was specified at start-up. The certificate is only used for acting as a KNIME node processing server with encrypted communication support. Fetching data from encrypting Internet sites, such as via https , does not require a server certificate.
• cactvs(ssl_server_key_file)
  The name of the SSL server key file if one was specified at start-up. The certificate is only used for acting as a KNIME node processing server with encrypted communication support. Fetching data from encrypting Internet sites, such as via https , does not require a server certificate.
• cactvs(ssl_server_support)
  A read-only flag indicating if the software was compiled with support for acting as an SSL -enabled KNIME node processing server, and additionally a valid certificate and key file set was provided at start-up and successfully used for initial SSL configuration. If no cert file is specified explicitly, a default localhost certificate/key file set stored in the knime subdirectory of ::cactvs(data_directory) is used, if the application was compiled with SSL server support and the file can be found.
• cactvs(standalone)
  A read-only boolean flag which is set for applications which encapsulate an application script and an interpreter into a single, stand-alone executable.
• cactvs(stationpath)
  The directory path where to look for auto-loaded station definition files.
• cactvs(strict_kekulization)
  If this flag is set, failures to generate a complete Kekulé structure when reading formats which encode aromatic bonds without an explicit bond order (such as some SMILES schemes) raises an error. By default, a structure with a partially resolved Kekulé system or single bonds is generated if no full resolution can be found, which might still be useful for structure matching, feature inspection, etc.
• cactvs(strict_smarts)
  If set, SMARTS specifications are interpreted according to strict Daylight specification. The default interpretation is more lenient, for example the aliphatic attribute of upper-case element symbols is not enforced to avoid the need for lengthy aromatic/aliphatic alternative symbols or # notation. Even without this flag, there are various methods to decode a substructure specification according to strict Daylight rules, for example by appending a ! character to the SMARTS string, or using appropriate decoder flags in ens create or molfile read commands. This option only applies to newly decoded SMARTS substructures. Substructures read from files such as cbin/cbase/bdb which encode the internal object structure of the toolkit already contain the interpretation implicitly and persistently as part of the atom and bond attribute set.
• cactvs(structure_security)
  If this boolean flag is set, no structure or reaction information is sent over Internet connections as a decodable connection table. It is off by default for academic distributions, but on for commercial packages.

If it is on, Internet lookup is still allowed by means of sending identifiers which are likely to be non-confidential (for example, CAS numbers, or PubChem CIDs and SIDs) or which cannot be reversed ( Cactvs hash codes). However, implicit sending of the structure as connection table to Internet services which provide computation or identifier lookup is suppressed if the flag is on. For example, computation of property E_CID for the PubChem identifier by means of contacting the PubChem database then always fails, regardless whether the structure has a CID or not, because that operation would require a potentially confidential structure to be sent as decodable InChI string to that database.

This flag can be changed by developers who know what they are doing. Also, direct scripting of any type of Internet access is possible regardless of the flag setting. This flag is a basic safeguard against unintentional data leakage.

The attribute is thread-local. Changing it has sets the default for future threads only if the modification is performed in the base thread, otherwise these inherit the current setting in the base thread.

• cactvs(superatom_table)
  The handle of the table with superatom expansion data (usually this is table1 ). This attribute is read-only.
• cactvs(swap_count)
  The number of objects which are currently swapped out (see ens swapout , reaction swapout commands). This element is read-only.
• cactvs(swap_directory)
  The name of a directory to use for ensemble and reaction swapping. By default it is initially an empty string, which is replaced by an automatically created process-specific subdirectory of the system temp directory once the swap subsystem has been initialized.

If this element is set to the name of an existing, writable directory before the first swap operation commences, that directory will be used instead. Changing the control variable value after the first object has been swapped has no effect. An automatically set up swap directory is deleted upon program shutdown. In a user swap directory, only the swap files are removed when the program exits.

• cactvs(swap_store_type)
  Select the type of object store used to swap out excessive numbers of ensemble and reaction objects (see for example the swapthreshold dataset object attribute). The default store is gdbm (simple key/value store), but it may also be set to none (use separate native Cactvs binary files) or tokyocabinet (advanced key/value store). The tokyocabinet store is not supported on Windows. Setting this attribute has only an effect before the first object is swapped out. If a method is set which is not supported, the best available method is instead automatically selected when the first object is swapped out, and the array variable element updated to the actually employed method.
• cactvs(swap_support)
  A read-only boolean flag indicating whether this interpreter supports the swapping of objects to a disk store.
• cactvs(system_encoding)
  The currently configured system encoding. By default, it is the same as ::cactvs(default_system_encoding).
• cactvs(table_count)
  The current number of table objects in the application. Note that not all tables necessarily have Tcl handles or Python wrapper objects, so there may be a discrepancy between this value and the result list length of the table list command.
• cactvs(table_support)
  A read-only boolean flag indicating whether this application was compiled with support for the chemistry-aware table object, and the associated table and tablex commands.
• cactvs(table_swap_threshold)
  Maximum object count of the datasets embedded in tables before disk swapping of these objects is automatically initiated. The default value is 10000. A negative value disables automatic disk swapping. This object-specific control value overrides the generic dataset object swap threshold in ::cactvs(dataset_swap_threshdold) .
• cactvs(tablexpath)
  The search path for table I/O module extensions
• cactvs(tcl_error_message)
  The last Tcl error message generated by the interpreter. This is a read-only element, and thread-local.
• cactvs(tcl_reference_objects)
  A flag indicating what type of Tcl interpreter data value objects are used for toolkit objects. The default value of zero indicates that object handles and object labels returned by executed commands are simple strings or numbers which are decoded when a new command is executed which uses them as arguments. A value of one indicates that the interpreter objects are actually wrappers for pre-resolved pointers. Using reference objects speeds up scripts, but slightly changes the pattern of handle allocations, and under many circumstances requires extra memory because toolkit objects remain in a zombie state until all interpreter references to a chemistry object have been reclaimed.
• cactvs(tcl_support)
  A read-only boolean flag indicating whether this interpreter support Tcl as scripting language. If seen from the Tcl side, this is obviously always true, but there may be Python -only interpreters where this flag is not set.
• cactvs(tcl_thread_count)
  A read-only integer with the total number of Tcl main interpreter threads. It is incremented for example by using thread::create or dataset addthread commands.
• cactvs(test_interpreter)
  The name of a Tcl slave interpreter which has been set up for regression testing. Usually an empty string and not used in user applications.
• cactvs(testdatapath)
  The search path for test data associated with extension modules for self-tests.
• cactvs(thread_count)
  The current number of threads registered with the core library. Every Tcl thread is also a library thread, but not every thread needs to be Tcl -enabled.
• cactvs(thread_support)
  A read-only boolean flag indicating whether the core library supports multiple threads. This is not equivalent tot he multithreaded flag, which indicates that multi-threaded Tcl script interpreters are supported. There are configurations which do not allow multiple parallel scripts, but support implicit multi-threading on operations such as file scanning from a single Tcl interpreter.
• cactvs(timezone)
  The current time zone in minutes west of GMT. This is used when setting up and storing time/date values. If the system clock is on GMT time, the value is always zero.
• cactvs(tk_support)
  A read-only boolean flag indicating whether this interpreter supports the Tk graphical toolkit as a compiled-in module. If not set, it is still possible to load Tk as dynamic module with the standard load or package Tcl commands.
• cactvs(tmpdir)
  The name of the directory for temporary files. This path can be changed and all future temporary files are then placed in that directory - and also automatically deleted if their controlling object is deleted. By default its value is the standard system temp directory.
• cactvs(tokyocabinet_support)
  A read-only boolean attribute indicating support of the Tokyo Cabinet key/value store. It this is available, the default object swap store is a Tokyo Cabinet file (instead of gdbm or separate native binary object serialization files), and the tc Tcl command extension module is present. Currently, the Windows version of the Cactvs suite does not support Tokyo Cabinet.
• cactvs(trace)
  A bit combination of flags to trace various subsystems. Symbolic names for the subsystems are translated into the proper bit. Example:

set cactvs(trace) ss

traces substructure matching.

• cactvs(tre_support)
  A read-only boolean flag indicating whether this interpreter supports extended regular expressions and approximate regular expressions by means of the Tre library, in addition to standard regular expressions. If it is not set, only standard PCRE/Perl regular expressions are supported.
• cactvs(trusted_executable_directory)
  The name of a directory which contains only trusted executables which may be invoked by the toolkit. Usually, this is the installation directory for executables bundled with the toolkit.
• cactvs(trusted_objectpath)
  A search path for trusted shared libraries, OSX bundles and Windows DLLs implementing extension modules. Depending on the extension loaded mode, objects in this path may still be loaded even if the loading of modules from the full set of search paths is disabled. See also : :cactvs(dynamic_loaded_mode) .
• cactvs(trusted_scriptpath)
  A search path for sources of trusted scripts. Scripts from this source may be loaded and executed even if normal script auto-loading is disabled.
• cactvs(typexpath)
  The search path for handlers of additional data types.
• cactvs(update_package)
  The package name this software was installed under, and which is used as file name component to find suitable updates in combination with the version and operating system data. For standard packages, this is cactvstools .
• cactvs(update_url)
  The directory URL where updates for this installation can be found. For commercial customers, this leads to a specific private area on our server, the academic version page is at https://xemistry.com/academic .
• cactvs(use_bad_property_cache)
  If this boolean flag is set, the toolkit remembers property names for which the look-up of property definition records failed. Since the look-up path can potgentially involve lengthy database searches and Internet accesses, this flag can in some cases prevent poor performance because of repeated failure to identify the same property name. On the other hand, if this flag is set, adding a new property definition during the runtime of an application after a look-up for this new property has failed has no effect and such a property definition needs to be loaded explicitly via its file.
• cactvs(user_address_city)
  The city part of the user contact address.
• cactvs(user_address_country)
  The country part of the user contact address. The country name must follow ISO3166 .
• cactvs(user_address_state)
  The state part of the user contact address. Empty if no applicable.
• cactvs(user_address_street)
  The street address of the user contact address. Includes floor, house number, etc.
• cactvs(user_address_zip)
  The ZIP code (or equivalent postal processing code) of the user address.
• cactvs(user_affiliation)
  The company, university or other institution the user is working for. This information is used in pre-setting various header data blocks. The veracity of this item is not checked. It is typically set by a configuration file.
• cactvs(user_affiliation_duns)
  The DUNS number of the user institution.
• cactvs(user_affiliation_url)
  A URL describing the user institution.
• cactvs(user_email)
  The e-mail address of the user, initially guessed by the library. This information is used in pre-setting various header data blocks, and also for Web data sources which require some identification. The veracity of this item is not checked. It is typically set by a configuration file.
• cactvs(user_id)
  The current system user name, as extracted from the login data or similar sources. Read only.
• cactvs(user_name)
  The full name of the user, if it could be determined from password database information. This information is used in pre-setting various header data blocks. The veracity of this item is not checked. It is typically set by a configuration file.
• cactvs(user_orcid)
  The ORCID of the user. The veracity of this item is not checked. It is typically set by a configuration file.
• cactvs(user_phone)
  A phone number of the user.
• cactvs(user_url)
  A URL with info on the user. The veracity of this item is not checked. It is typically set by a configuration file.
• cactvs(uuid_support)
  A read-only flag indicating whether the toolkit was compiled with support for handling and generating UUID s. This is usually true.
• cactvs(value_buffer_size)
  The maximum size of a single property data element may request when it is converted to a string. Normally set to something big like 256K, but can be reduced to cope with external tools which have maximum line sizes, etc.
• cactvs(verify_modified_property_values)
  If set, property values which are set or modified by script commands are immediately verified and the command fails of the verification fails. The verification process checks the new value complies with any constraints defined as part of the property definition, and whether the property check function (if it exists) also accepts the new value.
• cactvs(version)
  Version number of the Cactvs toolkit. Read only.
• cactvs(wedge_interpretation)
  This attribute can be used to switch the stereochemical interpretation of wedge bonds. The default model is cactvs , the other possible value is idbs for compatibility with IDBS software. In Cactvs mode, the stereo center is always at the wedge tips. In IDBS mode, bonds which go down have the wedge base at the stereo center. This flag also changes the style of generated wedges in 2D layouts (properties A_XY and B_FLAGS ).
• cactvs(wrapper)
  A read-only string which holds the name of a wrapper program (usually a Bourne shell or MSDOS script) invoking the interpreter, and possibly also setting a program script as hidden argument. For standard Cactvs installations, these are the cs?? scripts. In case a raw interpreter without a wrapper is run, this string is empty.
• cactvs(xdr_support)
  A read-only boolean attribute which indicates whether this application supports XDR -based Cactvs object streams. This feature is required for native Cactvs file I/O, handling serialized packed object strings, the object swap store, and other toolkit functions.
• cactvs(xml_support)
  A read-only boolean attributes which indicates whether the application was compiled with an integrated XML parser. This affects the availability of the soap command, as well as support for various XML -based chemical structure and reaction or table data file formats.