Registry¶

OPC UA namespace indices introduce an additional layer of complexity. o6\Python manages them in the process-wide o6.ns registry, so application code can normally use namespace shortnames and URIs instead of numeric indices.

print(o6.ns)

We can print the current state of this global registry and see something like:

o6.ns (count=128):
  name      uri                                    scope    version  pub_date    index
  ns0       http://opcfoundation.org/UA/           ::global 1.05.06              0
  amb       http://opcfoundation.org/UA/AMB/       ::global 1.01.1               ...
  ...

Process wide namespace indices¶

The indices in the last column are valid process wide. Different clients and servers in the same process therefore use the same canonical index for a given registry entry. Index 1 remains reserved for the application namespace; packaged namespaces receive indices as they are registered.

The same object provides metadata and declaration lookup:

di_namespace = o6.ns.di
same_namespace = o6.ns[di_namespace.index]
device_set = o6.ns["ns=di;i=5001"]

Shortnames are accessed as attributes. Numeric indices return the same namespace module. NodeId strings and NodeId objects return generated declarations; use filter() for URI, scope, or version queries.

Shortnames¶

very table entry has a name or shortname. This name uniquely identifies a namespace at a specific URI, scope, and version.

URI identity¶

The URI of a OPC UA nodeset specification should be uniquely identifying it. However in practice we are often required to have specific versions of a companion spec to deal with legacy systems. Even though the version has to be specified in a nodeset, the URI doesn't change with version updates.

o6.ns (count=129):
  name               uri                                                         scope    version  pub_date    index
  ns0                http://opcfoundation.org/UA/                                ::global 1.05.06              0
  di                 http://opcfoundation.org/UA/DI/                             ::global 1.05.0               ...
  ...
  di_1040            http://opcfoundation.org/UA/DI/                             ::global 1.04.0               51

In this case di is registered in two different versions. Note that the 'second' di has to use a different shortname and will be assined a unique global index.

Scope¶

Note that scope is a niche usecase for applications, where multiple clients and/or servers have to interact in the same process. You may skip this part.

A server's namespace 1 is automatically mapped once a client connects. Since this namespace is only relevant to the specific client it's scope is the actual endpoint of the server.

Once any nodeset is loaded into the address space of a server, it may also be modified by it. To address this, the scope poses as an indicator of where a namespace is valid. As a rule of thumb ::global namespace should be treated as immutable, meaning that no objects, datatypes, references, etc. are injected into this namespace by the server. This is, however, not enforced and a client may still source the ::global namespace di and connect to a server that modifies it's own di namespace after loading.

o6.ns (count=130):
  name               uri                                                         scope                              version     pub_date    index
  ns0                http://opcfoundation.org/UA/                                ::global                           1.05.06                 0
  di                 http://opcfoundation.org/UA/DI/                             ::global                           1.05.0                  ...
  ...
  client1_ns1        urn:o6-python:testserver:enhanced                           opc.tcp://my_server_endpoint:4840                          51

Automatic Namespace Translation¶

With this o6\Python doesn't need explicit management of namespace indices. Namepsaces can be identified by their human-readable shortname, which makes creating NodeIds extremely simple and easy to understand:

nodeId = o6.NodeId("ns=di;i=5001")
browseName = o6.QualifiedName("ns=di;DeviceSet")

On a client the can map this to the global namespace index for di and map it to the corresponding local index to which this particular client is connected. The exchange of the needed information for this mapping happens transparently immediately after the client has connected.

Packaged Companion specs¶

o6\Python comes with prepacked companion specs sourced from the offical UA-Nodeset git. All entries below are available out of the box by using o6.ns.<shortname>.

See also¶

• The OPC UA spec's normative treatment of namespaces and URIs: Part 3, §4.2 — URIs and Part 3, §4.4 — Node Model.
• How a server publishes its URI ↔ index table to clients, and where ns=1 (the local Server) is reserved: Part 5, §8.5 — Server Array and Namespace Array and Part 5, §6.3.1 — ServerType.
• The conceptual overview of namespaces, including ns0 / ns1 and the relationship to nodesets: Namespace and Nodeset Files & Companion Specs.
• How a namespace enters the global o6.ns registry, reaches a server's address space, and exposes its Python types: Loading & Using Nodesets.
• How a *.NodeSet2.xml becomes an importable namespace package: Compiling Nodesets.
• The o6-side NodeId / ExpandedNodeId / QualifiedName types that carry the index (or shortname / URI) in practice: Address & Identity Types.