Added functionality for multiple aliases as a list

Author: Deepak Mewar

docs/source/identifiers.rst

@@ -20,7 +20,7 @@ representations:
 1. An index (integer)
 2. A name (short string)
 3. A description (long string)
-4. An alias (optional short string)
+4. An alias (optional short string or list of short strings)
 
 
 Identifiers in IMAS-Python
@@ -51,7 +51,6 @@ the available identifiers is stored as ``imas.identifiers.identifiers``.
     mid = imas.identifiers.materials_identifier
     print(mid["235U"])        # Access by canonical name
     print(mid["U_235"])       # Access by alias
-    print(mid["235U"].alias)  # Print the alias
     
     # Both return the same object
     assert mid["235U"] is mid["U_235"]
@@ -98,7 +97,7 @@ below example:
     # 3. Assign an integer. This looks up the index in the identifier enum:
     core_sources.source[0].identifier = 1
 
-    # For identifiers with aliases, you can also assign using the alias:
+    # Identifiers can still be assigned with the old alias name for backward compatibility:
     materials = imas.IDSFactory().materials()
     materials.material.resize(1)
     mid = imas.identifiers.materials_identifier
@@ -125,20 +124,18 @@ below example:
 Identifier aliases
 ------------------
 
-Some identifiers may have aliases defined in the Data Dictionary. An alias provides
-an alternative name for accessing the same identifier value. This is particularly
-useful where multiple naming conventions exist.
+Some identifiers may have multiple aliases defined in the Data Dictionary. Aliases are
+former names kept as an option to ensure better backward compatibility after a change
+and support multiple naming conventions. An identifier can have any number of
+comma-separated aliases.
 
-Aliases can be accessed in the same ways as canonical names.
-
-Aliases starting with a number can be accessible using ["235U"] but not 
-material_identifier.235U because of Python construct limitation.
+Aliases can be accessed in the same ways as canonical names, and all aliases for an
+identifier point to the same object.
 
 Aliases that begin with a number (e.g., 235U) cannot be accessed using dot notation 
-(e.g., material_identifier.235U) due to Python’s syntax restrictions. Instead, such 
-aliases must be accessed using dictionary-style indexing, 
-for example: material_identifier["235U"].
-
+(e.g., material_identifier.235U) due to Python's syntax restrictions. Instead, such
+aliases must be accessed using dictionary-style indexing, for example:
+material_identifier["235U"].
 
 .. code-block:: python
     :caption: Working with identifier aliases
@@ -151,27 +148,30 @@ for example: material_identifier["235U"].
     # Access by canonical name
     uranium235_by_name = mid["235U"]
     print(f"Name: {uranium235_by_name.name}")
-    print(f"Alias: {uranium235_by_name.alias}")
+    print(f"Aliases: {uranium235_by_name.aliases}")  # List of all aliases
+    print(f"First alias: {uranium235_by_name.alias}")  # First alias for compatibility
     print(f"Index: {uranium235_by_name.index}")
     print(f"Description: {uranium235_by_name.description}")
     
-    # Access by alias - returns the same object
-    uranium235_by_alias = mid["U_235"]
-    print(f"Same object: {uranium235_by_name is uranium235_by_alias}")
+    # Access by any alias - all return the same object
+    uranium235_by_alias1 = mid["U_235"]
+    uranium235_by_alias2 = mid["Uranium_235"]
+    print(f"Same objects: {uranium235_by_name is uranium235_by_alias1 is uranium235_by_alias2}")
     
     # You can also use attribute access for aliases (when valid Python identifiers)
     uranium235_by_attr = mid.U_235
     print(f"Same object: {uranium235_by_name is uranium235_by_attr}")
     
-    # When assigning to IDS structures, aliases work the same way
+    # When assigning to IDS structures, any alias works the same way
     materials = imas.IDSFactory().materials()
     materials.material.resize(1)
     
-    # These assignments are equivalent:
-    materials.material[0].identifier = "235U"    # canonical name
-    materials.material[0].identifier = "U_235"   # alias
-    materials.material[0].identifier = mid["235U"]  # enum value
-    materials.material[0].identifier = mid.U_235    # enum value via alias
+    # These assignments are all equivalent:
+    materials.material[0].identifier = "235U"          # canonical name
+    materials.material[0].identifier = "U_235"         # first alias
+    materials.material[0].identifier = "Uranium_235"   # another alias
+    materials.material[0].identifier = mid["235U"]     # enum value
+    materials.material[0].identifier = mid.U_235       # enum value via alias
 
 
 Compare identifiers

imas/ids_identifiers.py

@@ -1,7 +1,6 @@
 # This file is part of IMAS-Python.
 # You should have received the IMAS-Python LICENSE file with this project.
-"""IMAS-Python module to support Data Dictionary identifiers.
-"""
+"""IMAS-Python module to support Data Dictionary identifiers."""
 
 import logging
 from enum import Enum, EnumMeta
@@ -30,20 +29,34 @@ def __getitem__(cls, name):
 
 
 class IDSIdentifier(Enum, metaclass=IDSIdentifierMeta):
+    # class IDSIdentifier(Enum):
     """Base class for all identifier enums."""
 
-    def __new__(self, value: int, description: str, alias: str = None):
-        obj = object.__new__(self)
+    def __new__(cls, value: int, description: str, aliases=None):
+        obj = object.__new__(cls)
         obj._value_ = value
         return obj
 
-    def __init__(self, value: int, description: str, alias: str = None) -> None:
+    def __init__(self, value: int, description: str, aliases=None) -> None:
         self.index = value
         """Unique index for this identifier value."""
         self.description = description
         """Description for this identifier value."""
-        self.alias = alias
-        """Alias for this identifier value (if any)."""
+
+        # Store aliases as a list for multi-alias support; keep a single 'alias'
+        # attribute pointing to the first alias for backwards compatibility.
+        if aliases is None:
+            self.aliases = []
+        else:
+            # Accept either a single string or list of strings
+            if isinstance(aliases, str):
+                # comma-separated string -> list
+                parsed = [a.strip() for a in aliases.split(",") if a.strip()]
+            else:
+                parsed = list(aliases)
+            self.aliases = parsed
+        if self.aliases:
+            self.alias = self.aliases[0]
 
     def __eq__(self, other):
         if self is other:
@@ -52,37 +65,33 @@ def __eq__(self, other):
             other_name = str(other.name)
             other_index = int(other.index)
             other_description = str(other.description)
-            other_alias = getattr(other, "alias", None)
         except (AttributeError, TypeError, ValueError):
             # Attribute doesn't exist, or failed to convert
             return NotImplemented
+
         # Index must match
         if other_index == self.index:
             # Name may be left empty, or match name or alias
-            name_matches = (
+            if (
                 other_name == self.name
                 or other_name == ""
-                or (self.alias and other_name == self.alias)
-                or (other_alias and other_alias == self.name)
-                or (self.alias and other_alias and self.alias == other_alias)
-            )
-            if name_matches:
+                or other_name in getattr(self, "aliases", [])
+            ):
                 # Description doesn't have to match, though we will warn when it doesn't
-                if other_description != self.description and other_description != "":
+                if other_description not in (self.description, ""):
                     logger.warning(
                         "Description of %r does not match identifier description %r",
                         other.description,
                         self.description,
                     )
                 return True
-            else:
-                logger.warning(
-                    "Name %r does not match identifier name %r or "
-                    "alias %r, but indexes are equal.",
-                    other.name,
-                    self.name,
-                    self.alias,
-                )
+
+            # If we get here with matching indexes but no name/alias match, warn
+            logger.warning(
+                "Name %r does not match identifier name %r, but indexes are equal.",
+                other.name,
+                self.name,
+            )
         return False
 
     @classmethod
@@ -92,16 +101,21 @@ def _from_xml(cls, identifier_name, xml) -> Type["IDSIdentifier"]:
         aliases = {}
         for int_element in element.iterfind("int"):
             name = int_element.get("name")
-            alias = (
-                int_element.get("alias")
-                if int_element.get("alias") is not None
-                else None
-            )
             value = int_element.text
             description = int_element.get("description")
-            enum_values[name] = (int(value), description, alias)
-            if alias:
-                aliases[alias] = name
+            # alias attribute may contain multiple comma-separated aliases
+            alias_attr = int_element.get("alias")
+            if alias_attr:
+                aliases = [a.strip() for a in alias_attr.split(",") if a.strip()]
+            else:
+                aliases = []
+            # Canonical entry: use the canonical 'name' as key
+            enum_values[name] = (int(value), description, aliases)
+            # Also add alias names as enum *aliases* (they become enum attributes)
+            # only if they are valid Python identifiers and not already present.
+            for match in aliases:
+                if match and match not in enum_values:
+                    enum_values[match] = (int(value), description, aliases)
         # Create the enumeration
         enum = cls(
             identifier_name,
@@ -110,9 +124,6 @@ def _from_xml(cls, identifier_name, xml) -> Type["IDSIdentifier"]:
             qualname=f"{__name__}.{identifier_name}",
         )
         enum.__doc__ = element.find("header").text
-        enum._aliases = aliases
-        for alias, canonical_name in aliases.items():
-            setattr(enum, alias, getattr(enum, canonical_name))
         return enum