sapiopycommons 2025.7.7a580__py3-none-any.whl → 2025.7.9a582__py3-none-any.whl

sapiopycommons/rules/eln_rule_handler.py

@@ -126,16 +126,12 @@ class ElnRuleHandler:
         """
         return list(self._entry_to_field_maps.keys())
 
-    # CR-47529: Add info about HVDT behavior to the docstring of these functions.
     def get_records(self, data_type: DataTypeIdentifier, entry: str | None = None) -> list[DataRecord]:
         """
         Get records from the cached context with the given data type. Capable of being filtered to searching within
         the context of an entry name. If the given data type or entry does not exist in the context,
         returns an empty list.
 
-        Note that if you are attempting to retrieve record that are high volume data types and are receiving nothing,
-        the HVDTs may have been sent as field maps. Consider using the get_field_maps function if this occurs.
-
         :param data_type: The data type of the records to return.
         :param entry: The name of the entry to grab the records from. If None, returns the records that match the data
             type from every entry. If an entry is provided, but it does not exist in the context, returns an empty list.
@@ -154,7 +150,7 @@ class ElnRuleHandler:
 
         Field maps will only exist in the context if the data record that the fields are from is no longer accessible
         to the user. This can occur because the data record was deleted, or because the user does not have access to the
-        record due to ACL. This can also occur under certain circumstances if the records are HVDTs.
+        record due to ACL.
 
         :param data_type: The data type of the field maps to return.
         :param entry: The name of the entry to grab the field maps from. If None, returns the field maps that match the
@@ -174,9 +170,6 @@ class ElnRuleHandler:
         within the context of an entry name. If the given data type or entry does not exist in the context,
         returns an empty list.
 
-        Note that if you are attempting to retrieve record that are high volume data types and are receiving nothing,
-        the HVDTs may have been sent as field maps. Consider using the get_field_maps function if this occurs.
-
         :param wrapper_type: The record model wrapper or data type name of the record to get from the context.
         :param entry: The name of the entry to grab the records from. If None, returns the records that match the data
             type from every entry. If an entry is provided, but it does not exist in the context, returns an empty list.

sapiopycommons/rules/on_save_rule_handler.py

@@ -122,16 +122,12 @@ class OnSaveRuleHandler:
         """
         return list(self._base_id_to_field_maps.keys())
 
-    # CR-47529: Add info about HVDT behavior to the docstring of these functions.
     def get_records(self, data_type: DataTypeIdentifier, record_id: int | None = None) -> list[DataRecord]:
         """
         Get records from the cached context with the given data type. Capable of being filtered to searching within
         the context of a record ID. If the given data type or record ID does not exist in the context,
         returns an empty list.
 
-        Note that if you are attempting to retrieve record that are high volume data types and are receiving nothing,
-        the HVDTs may have been sent as field maps. Consider using the get_field_maps function if this occurs.
-
         :param data_type: The data type of the records to return.
         :param record_id: The record ID of the base record to search from. If None, returns the records that match the
             data type from every ID. If an ID is provided, but it does not exist in the context, returns an empty list.
@@ -150,7 +146,7 @@ class OnSaveRuleHandler:
 
         Field maps will only exist in the context if the data record that the fields are from is no longer accessible
         to the user. This can occur because the data record was deleted, or because the user does not have access to the
-        record due to ACL. This can also occur under certain circumstances if the records are HVDTs.
+        record due to ACL.
 
         :param data_type: The data type of the field maps to return.
         :param record_id: The record ID of the base record to search from. If None, returns the field maps that match
@@ -170,9 +166,6 @@ class OnSaveRuleHandler:
         the context of a record ID. If the given data type or record ID does not exist in the context,
         returns an empty list.
 
-        Note that if you are attempting to retrieve record that are high volume data types and are receiving nothing,
-        the HVDTs may have been sent as field maps. Consider using the get_field_maps function if this occurs.
-
         :param wrapper_type: The record model wrapper or data type name of the record to get from the context.
         :param record_id: The record ID of the base record to search from. If None, returns the records that match the
             data type from ID. If an ID is provided, but it does not exist in the context, returns an empty list.

sapiopycommons/webhook/webhook_handlers.py

@@ -220,9 +220,6 @@ class CommonsWebhookHandler(AbstractWebhookHandler):
         else:
             self.custom_context = None
 
-        # CR-47526: Set the dialog timeout to 1 hour by default. This can be overridden by the webhook.
-        self.callback.set_dialog_timeout(3600)
-
         # Set the default display types, titles, and messages for each type of exception that can display a message.
         self.default_user_error_display_type = MessageDisplayType.TOASTER_WARNING
         self.default_critical_error_display_type = MessageDisplayType.DISPLAY_ERROR

sapiopycommons/webhook/webservice_handlers.py

@@ -3,7 +3,7 @@ import traceback
 from abc import abstractmethod, ABC
 from base64 import b64decode
 from logging import Logger
-from typing import Any, Mapping
+from typing import Any
 
 from flask import request, Response, Request
 from sapiopylib.rest.DataRecordManagerService import DataRecordManager
@@ -122,7 +122,7 @@ class AbstractWebserviceHandler(AbstractWebhookHandler):
         """
         pass
 
-    def authenticate_user(self, headers: Mapping[str, str]) -> SapioUser:
+    def authenticate_user(self, headers: dict[str, str]) -> SapioUser:
         """
         Authenticate a user for making requests to a Sapio server using the provided headers. If no user can be
         authenticated, then an exception will be thrown.

{sapiopycommons-2025.7.7a580.dist-info → sapiopycommons-2025.7.9a582.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: sapiopycommons
-Version: 2025.7.7a580
+Version: 2025.7.9a582
 Summary: Official Sapio Python API Utilities Package
 Project-URL: Homepage, https://github.com/sapiosciences
 Author-email: Jonathan Steck <jsteck@sapiosciences.com>, Yechen Qiao <yqiao@sapiosciences.com>
@@ -17,7 +17,7 @@ Classifier: Topic :: Scientific/Engineering :: Bio-Informatics
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Requires-Python: >=3.10
 Requires-Dist: databind>=4.5
-Requires-Dist: sapiopylib>=2025.4.17.264
+Requires-Dist: sapiopylib>=2024.5.24.210
 Description-Content-Type: text/markdown
 
 

sapiopycommons-2025.7.9a582.dist-info/RECORD

@@ -0,0 +1,92 @@
+sapiopycommons/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+sapiopycommons/ai/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+sapiopycommons/ai/protobuf_utils.py,sha256=5Y0z_lRVipbHPJcHJf9GosK-ZjAh_I2JI3QwV8iyfKg,24884
+sapiopycommons/ai/test_client.py,sha256=8AlRTuy7XUC40aU4SgTQkNc_ZBp_ANhVNEKbUx8ABRM,10430
+sapiopycommons/ai/tool_service_base.py,sha256=8it0853p-kw3Y1SdEyEfmxCbxM3_poUTJKFUaZ5MrCQ,35366
+sapiopycommons/ai/api/fielddefinitions/proto/fields_pb2.py,sha256=YcZjb_YM-XeLErM8hEC_S7vGMVGvcXAMGs2b-u5zvOE,2377
+sapiopycommons/ai/api/fielddefinitions/proto/fields_pb2.pyi,sha256=FwtXmNAf7iYGEFm4kbqb04v77jNHbZg18ZmEDhle_bU,1444
+sapiopycommons/ai/api/fielddefinitions/proto/fields_pb2_grpc.py,sha256=wPImJPdCUZNVEVoUWzsba9kGIXjEKPdUkawP5SnVyiU,932
+sapiopycommons/ai/api/fielddefinitions/proto/velox_field_def_pb2.py,sha256=nWC91vR2pMgMUyNOZRZ0YiuL1-8ntnjXLqt1daxsD34,20869
+sapiopycommons/ai/api/fielddefinitions/proto/velox_field_def_pb2.pyi,sha256=U5zXrbBxsWilLTsRWJd1TqjdjLKFsr3enF9OJ8GfyWw,34028
+sapiopycommons/ai/api/fielddefinitions/proto/velox_field_def_pb2_grpc.py,sha256=4vD4jWanaJ4uclSkFmS7JIz_lwYXDWBE3DomuPjUyII,941
+sapiopycommons/ai/api/plan/proto/step_output_pb2.py,sha256=JpBZSyoYyPTEaaXjW664PeJNK0zxV1mly_kp5re42z4,2661
+sapiopycommons/ai/api/plan/proto/step_output_pb2.pyi,sha256=yuxOYnDZ9DRuu-TLzaKOW_B4LUiYxTrNc2AbssXg4kE,2022
+sapiopycommons/ai/api/plan/proto/step_output_pb2_grpc.py,sha256=vDRY_pIIshQ4UpdW-ra1F5zBmntdsW2scySkMAA-zfc,925
+sapiopycommons/ai/api/plan/proto/step_pb2.py,sha256=nL976oTFdX4ih4gg7_J-8eFoGB69tFvERB2gT3L2-6s,2439
+sapiopycommons/ai/api/plan/proto/step_pb2.pyi,sha256=QPIcsjcUvEGQkdZMUMiVzFFNDl8yOUe_qJtf5XEp5Ck,2062
+sapiopycommons/ai/api/plan/proto/step_pb2_grpc.py,sha256=DgiBYFvTNiDG_2a9Tpt5iel2fRUfePZWP41fZTC-KWk,918
+sapiopycommons/ai/api/plan/script/proto/script_pb2.py,sha256=D668fAG3dAvE8ijCzaflj7o6D5M5szW4X8Wq-8EYxBU,4712
+sapiopycommons/ai/api/plan/script/proto/script_pb2.pyi,sha256=VS9WXKcGuUj6ulziLxhgEBMRXP-QgHlFeMISDDOhAQY,7174
+sapiopycommons/ai/api/plan/script/proto/script_pb2_grpc.py,sha256=RkShHpe_d5EJHk3qp-or1JpvSEqShb7cCiaXnJ2YSww,6931
+sapiopycommons/ai/api/plan/tool/proto/entry_pb2.py,sha256=A-ufAWwbJ0odVXBZBQKvke6LYPijPl2dpb2IFRaXmPE,4124
+sapiopycommons/ai/api/plan/tool/proto/entry_pb2.pyi,sha256=NNBrdHz5PzAuUEXuGgTU4THy9rx8Sr9iGTb65QtVH4Q,4589
+sapiopycommons/ai/api/plan/tool/proto/entry_pb2_grpc.py,sha256=YKkX2kexERUx4asLCShufSnZhgf339Zk8Xw1FAgLfHQ,924
+sapiopycommons/ai/api/plan/tool/proto/tool_pb2.py,sha256=jrSgsSx8mGPWuxYPxOom7l925bavWaX4NEQAkC9niJo,6854
+sapiopycommons/ai/api/plan/tool/proto/tool_pb2.pyi,sha256=KzOmH-ic0anjRta4jhScMRCOI1OtO5rSZrQDr_W3eZ0,15992
+sapiopycommons/ai/api/plan/tool/proto/tool_pb2_grpc.py,sha256=68u5E1ZKha5frP5GuY8Ad-c0c79vBhtfnj5Q4u-8xOY,6982
+sapiopycommons/ai/api/session/proto/sapio_conn_info_pb2.py,sha256=WKzNi-d5dqeJbmEXUVE5qJ4Qm34HmsqRXRtXih382g8,2100
+sapiopycommons/ai/api/session/proto/sapio_conn_info_pb2.pyi,sha256=vLYA8Tkzq2AwgVadoUp5vAg4HgGlgga0kzeS3e_XkCQ,1621
+sapiopycommons/ai/api/session/proto/sapio_conn_info_pb2_grpc.py,sha256=2W0YzT4SfnGTLq98AdvkyNM0n75Tkl8DervPS1ryGao,932
+sapiopycommons/callbacks/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+sapiopycommons/callbacks/callback_util.py,sha256=sz76LzD9sVLPMcoOpmzPe1aILGXcpHfyZ-qex8oR11c,130849
+sapiopycommons/callbacks/field_builder.py,sha256=p2XacN99MuKk3ite8GAqstUMpixqugul2CsC4gB83-o,38620
+sapiopycommons/chem/IndigoMolecules.py,sha256=slM2y39zZFHc468c366EqR8T-GYJ24UnM9HWAqWFEwQ,3900
+sapiopycommons/chem/Molecules.py,sha256=5PzRyE1s-Z3nfwh3Y4dCNdQOIJGhog08wyZvgTkKwyU,12384
+sapiopycommons/chem/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+sapiopycommons/customreport/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+sapiopycommons/customreport/auto_pagers.py,sha256=3-XXWrP7r41a_Y-8YLPnfm0s65m4qEEUqu4azX47oPI,14828
+sapiopycommons/customreport/column_builder.py,sha256=0RO53e9rKPZ07C--KcepN6_tpRw_FxF3O9vdG0ilKG8,3014
+sapiopycommons/customreport/custom_report_builder.py,sha256=BlTxZ4t1sfZA2Ciur1EfYvkZxHxJ7ADwYNAe2zwiN0c,7176
+sapiopycommons/customreport/term_builder.py,sha256=PNp71NF1vFxidk5v6uQNi9oQR9KJIk8WfhyntvvZN-U,18573
+sapiopycommons/datatype/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+sapiopycommons/datatype/attachment_util.py,sha256=N-nhsJ0oxa_Ft6Y6VWeNFYLzfuQqsjhHA6_-yIt2wVw,3596
+sapiopycommons/datatype/data_fields.py,sha256=pczUlEcE0TeHEDU0Gkvu7voacSLPXCB7l9UbI1Tb6V0,5656
+sapiopycommons/datatype/pseudo_data_types.py,sha256=6TG7aJxgmUZ8FQkWBcgmbK5oy7AFFNtKOPpi1w1OOYA,27657
+sapiopycommons/eln/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+sapiopycommons/eln/experiment_handler.py,sha256=FeqmjnxN5WyDDstN3_AMSo9r7nQi-5zou4m-3K5JsYM,123363
+sapiopycommons/eln/experiment_report_util.py,sha256=NNNNPVD3_2ZAjoOqCMOnlnmPD0SCjDcgYi453ATSJBs,37027
+sapiopycommons/eln/experiment_tags.py,sha256=7-fpOiSqrjbXmWIJhEhaxMgLsVCPAtKqH8xRzpDVKoE,356
+sapiopycommons/eln/plate_designer.py,sha256=ix2cflz13PAHyu4deS3d5Qd3kQXk0C7IQxBQ2Dm9fEM,13692
+sapiopycommons/files/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+sapiopycommons/files/complex_data_loader.py,sha256=T39veNhvYl6j_uZjIIJ8Mk5Aa7otR5RB-g8XlAdkksA,1421
+sapiopycommons/files/file_bridge.py,sha256=vKbqxPexi15epr_-_qLrEfYoxNxB031mXN92iVtOMqE,9511
+sapiopycommons/files/file_bridge_handler.py,sha256=SEYDIQhSCmjI6qyLdDJE8JVKSd0WYvF7JvAq_Ahp9Do,25503
+sapiopycommons/files/file_data_handler.py,sha256=f96MlkMuQhUCi4oLnzJK5AiuElCp5jLI8_sJkZVwpws,36779
+sapiopycommons/files/file_util.py,sha256=w4Q7zYJb9YaPxrecmT4RT_OOibKMRP0NI1CyoOLfAP4,31747
+sapiopycommons/files/file_validator.py,sha256=ryg22-93csmRO_Pv0ZpWphNkB74xWZnHyJ23K56qLj0,28761
+sapiopycommons/files/file_writer.py,sha256=hACVl0duCjP28gJ1NPljkjagNCLod0ygUlPbvUmRDNM,17605
+sapiopycommons/flowcyto/flow_cyto.py,sha256=vs9WhXXKz3urpjL8QKSk56B-NSmQR3O3x_WFBKoeO10,3227
+sapiopycommons/flowcyto/flowcyto_data.py,sha256=mYKFuLbtpJ-EsQxLGtu4tNHVlygTxKixgJxJqD68F58,2596
+sapiopycommons/general/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+sapiopycommons/general/accession_service.py,sha256=QeNGd78Zr08ezWpThTuAkxO4bXusEcp5x9jJRZRwliA,13483
+sapiopycommons/general/aliases.py,sha256=alc2R5TOSKbZif3pcGZ706y23Y9F4HQPC-Kj4xJZ_Us,14503
+sapiopycommons/general/audit_log.py,sha256=KQq0PsvukUoE3l6TQb3-vpu5-MbSINpWlnQ9e7jojPg,8743
+sapiopycommons/general/custom_report_util.py,sha256=NwwmejSQLwSbrndEk1gPyFNYk9GZoS7Wrp9ab9moFgw,18014
+sapiopycommons/general/directive_util.py,sha256=7SeQrd2Ye5JHlXZtJZaVGgtaSLdq_Vm9EObuxf44Pz8,3905
+sapiopycommons/general/exceptions.py,sha256=aPlzK1cvxeMU5UsokYlLrIBGltUfJZ7LH8zvLh9DxpI,3233
+sapiopycommons/general/html_formatter.py,sha256=HE3OeGgwOw6x53zGSc4-UzP4-JoOmQIz3pX-DzNVg94,17138
+sapiopycommons/general/popup_util.py,sha256=HKILegU1uCL_6abNlNL0Wn3xgX2JNa_kJeq7e5CZu6Q,31923
+sapiopycommons/general/sapio_links.py,sha256=YkcVKNLrSGoM7tCCXBAsIbIxylctwdcEyhePrRMODe0,2859
+sapiopycommons/general/storage_util.py,sha256=ovmK_jN7v09BoX07XxwShpBUC5WYQOM7dbKV_VeLXJU,8892
+sapiopycommons/general/time_util.py,sha256=jU1urPoZRv6evNucR0-288EyT4PrsDpCr-H1-7BKq9A,12363
+sapiopycommons/multimodal/multimodal.py,sha256=PFaGJPbKvW__tnxb8KkgkJZOKjQdgxF_kGfD5chet1s,6779
+sapiopycommons/multimodal/multimodal_data.py,sha256=0BeVPr9HaC0hNTF1v1phTIKGruvNnwerHsD994qJKBg,15099
+sapiopycommons/processtracking/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+sapiopycommons/processtracking/custom_workflow_handler.py,sha256=QZVRDUXpHfYIKD9LtaOcOt0Sr3RGDaeGQb-LZYAgkCc,25117
+sapiopycommons/processtracking/endpoints.py,sha256=w5bziI2xC7450M95rCF8JpRwkoni1kEDibyAux9B12Q,10848
+sapiopycommons/recordmodel/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+sapiopycommons/recordmodel/record_handler.py,sha256=aPbR3OS0RlsKOGztY-LZaOmkXKUB8ZTw3qqdJKXwd6U,70872
+sapiopycommons/rules/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+sapiopycommons/rules/eln_rule_handler.py,sha256=1aC88brATcjL1O0Hd2hQ0XNguKsKh8xELXComotk3mQ,10772
+sapiopycommons/rules/on_save_rule_handler.py,sha256=J1YKjOGA1KUTwpnZMa7oIi5QU_4mBJrPygSHNDsMIIA,10539
+sapiopycommons/samples/aliquot.py,sha256=mWOJUqaQh0t3HklNuGdmuV7D5zzXs6fpLwtDdM6_XTo,3018
+sapiopycommons/sftpconnect/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+sapiopycommons/sftpconnect/sftp_builder.py,sha256=lFK3FeXk-sFLefW0hqY8WGUQDeYiGaT6yDACzT_zFgQ,3015
+sapiopycommons/webhook/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+sapiopycommons/webhook/webhook_context.py,sha256=D793uLsb1691SalaPnBUk3rOSxn_hYLhdvkaIxjNXss,1909
+sapiopycommons/webhook/webhook_handlers.py,sha256=L0HetSm43NvA5KyW3xbLpGFh2DbAaeZJVtXIEl2fvV8,39689
+sapiopycommons/webhook/webservice_handlers.py,sha256=Y5dHx_UFWFuSqaoPL6Re-fsKYRuxvCWZ8bj6KSZ3jfM,14285
+sapiopycommons-2025.7.9a582.dist-info/METADATA,sha256=HBCsgpHoxOvmMOEjgVaJ8QFBOYbCWTpP8Ctd8N4rWf8,3142
+sapiopycommons-2025.7.9a582.dist-info/WHEEL,sha256=C2FUgwZgiLbznR-k0b_5k3Ai_1aASOXDss3lzCUsUug,87
+sapiopycommons-2025.7.9a582.dist-info/licenses/LICENSE,sha256=HyVuytGSiAUQ6ErWBHTqt1iSGHhLmlC8fO7jTCuR8dU,16725
+sapiopycommons-2025.7.9a582.dist-info/RECORD,,

sapiopycommons/chem/ps_commons.py

@@ -1,455 +0,0 @@
-"""
-Parallel Synthesis Commons
-Author: Yechen Qiao
-"""
-import json
-from dataclasses import dataclass
-from typing import Any
-
-from indigo import IndigoObject
-from sapiopycommons.chem.IndigoMolecules import indigo, get_aromatic_dearomatic_forms, renderer
-
-
-class SerializableQueryMolecule:
-    mol_block: str
-    smarts: str
-    render_svg: str
-
-    @staticmethod
-    def create(query_molecule: IndigoObject):
-        aromatic, dearomatic = get_aromatic_dearomatic_forms(query_molecule)
-        ret: SerializableQueryMolecule = SerializableQueryMolecule()
-        ret.mol_block = aromatic.molfile()
-        ret.smarts = aromatic.smarts()
-        ret.render_svg = renderer.renderToString(dearomatic)
-        return ret
-
-    def to_json(self) -> dict[str, Any]:
-        """
-        Save the SerializableQueryMolecule to a JSON string.
-        :return: A JSON string representation of the query molecule.
-        """
-        return {
-            "mol_block": self.mol_block,
-            "smarts": self.smarts,
-            "render_svg": self.render_svg
-        }
-
-
-class SerializableMoleculeMatch:
-    """
-    A serializable match that stores and loads a match that can be serialized to JSON.
-    """
-    _query_atom_to_atom: dict[int, int]
-    _query_bond_to_bond: dict[int, int]
-    _query_molecule_file: str
-    _matching_molecule_file: str
-    _query_molecule: IndigoObject
-    _matching_molecule: IndigoObject
-    _record_id: int  # Only when received from Sapio.
-
-    @property
-    def record_id(self) -> int:
-        """
-        Get the record ID of the match.
-        :return: The record ID.
-        """
-        return self._record_id
-
-    def __str__(self):
-        return json.dumps(self.to_json())
-
-    def __hash__(self):
-        return hash(self._query_molecule.smarts())
-
-    def __eq__(self, other):
-        if not isinstance(other, SerializableMoleculeMatch):
-            return False
-        if self._query_atom_to_atom == other._query_atom_to_atom and \
-                self._query_bond_to_bond == other._query_bond_to_bond and \
-                self._query_molecule_file == other._query_molecule_file and \
-                self._matching_molecule_file == other._matching_molecule_file and \
-                self._record_id == other._record_id:
-            return True
-        if self._query_molecule.smarts() != other._query_molecule.smarts():
-            return False
-        return are_symmetrical_subs(self, other)
-
-    def mapAtom(self, atom: IndigoObject) -> IndigoObject | None:
-        if not self._query_atom_to_atom or atom.index() not in self._query_atom_to_atom:
-            return None
-        index = self._query_atom_to_atom[atom.index()]
-        return self._matching_molecule.getAtom(index)
-
-    def mapBond(self, bond: IndigoObject) -> IndigoObject | None:
-        if not self._query_bond_to_bond or bond.index() not in self._query_bond_to_bond:
-            return None
-        index = self._query_bond_to_bond[bond.index()]
-        return self._matching_molecule.getBond(index)
-
-    def to_json(self) -> dict[str, Any]:
-        """
-        Save the SerializableMoleculeMatch to a JSON string.
-        :return: A JSON string representation of the match.
-        """
-        return {
-            "query_molecule_file": self._query_molecule_file,
-            "matching_molecule_file": self._matching_molecule_file,
-            "query_atom_to_atom": self._query_atom_to_atom,
-            "query_bond_to_bond": self._query_bond_to_bond,
-            "record_id": self._record_id
-        }
-
-    @staticmethod
-    def from_json(json_dct: dict[str, Any]) -> 'SerializableMoleculeMatch':
-        """
-        Load a SerializableMoleculeMatch from a JSON string.
-        :param json_dct: A JSON string representation of the match.
-        :return: A new SerializableMoleculeMatch instance.
-        """
-        smm = SerializableMoleculeMatch()
-        smm._query_atom_to_atom = {}
-        for key, value in json_dct.get("query_atom_to_atom", {}).items():
-            smm._query_atom_to_atom[int(key)] = int(value)
-        smm._query_bond_to_bond = {}
-        for key, value in json_dct.get("query_bond_to_bond", {}).items():
-            smm._query_bond_to_bond[int(key)] = int(value)
-        smm._query_molecule_file = json_dct.get("query_molecule_file")
-        smm._matching_molecule_file = json_dct.get("matching_molecule_file")
-        smm._query_molecule = indigo.loadQueryMolecule(smm._query_molecule_file)
-        smm._matching_molecule = indigo.loadMolecule(smm._matching_molecule_file)
-        smm._record_id = json_dct.get("record_id", 0)  # Default to 0 if not present
-        return smm
-
-    @staticmethod
-    def create(query_molecule: IndigoObject, matching_molecule: IndigoObject,
-               match: IndigoObject) -> 'SerializableMoleculeMatch':
-        """
-        Create a SerializableMoleculeMatch from a query molecule, matching molecule, and match.
-        :param query_molecule: The query molecule.
-        :param matching_molecule: The matching molecule.
-        :param match: The match object containing atom mappings.
-        :return: A new SerializableMoleculeMatch instance.
-        """
-        smm = SerializableMoleculeMatch()
-        smm._query_atom_to_atom = {}
-        smm._query_bond_to_bond = {}
-        smm._query_molecule = query_molecule.clone()
-        smm._matching_molecule = matching_molecule.clone()
-        smm._query_molecule_file = query_molecule.molfile()
-        smm._matching_molecule_file = matching_molecule.molfile()
-        smm._record_id = 0
-
-        for qatom in query_molecule.iterateAtoms():
-            concrete_atom = match.mapAtom(qatom)
-            if concrete_atom is None:
-                continue
-            smm._query_atom_to_atom[qatom.index()] = concrete_atom.index()
-
-        for qbond in query_molecule.iterateBonds():
-            concrete_bond = match.mapBond(qbond)
-            if concrete_bond is None:
-                continue
-            smm._query_bond_to_bond[qbond.index()] = concrete_bond.index()
-        return smm
-
-    def get_matched_molecule_copy(self):
-        return self._matching_molecule.clone()
-
-
-@dataclass
-class ReplacementReaction:
-    """
-    A replacement reaction stores reactio template with 1 reactant replaced by specific user match.
-    """
-    reaction: IndigoObject
-    reaction_reactant: IndigoObject
-    replacement_reactant: IndigoObject
-    replacement_query_reaction_match: SerializableMoleculeMatch
-
-
-# noinspection PyProtectedMember
-def highlight_mol_substructure_serial_match(molecule: IndigoObject, serializable_match: SerializableMoleculeMatch):
-    """
-    Highlight the substructure in the molecule based on the SerializableMoleculeMatch.
-    :param molecule: The molecule to highlight.
-    :param serializable_match: The SerializableMoleculeMatch containing atom mappings.
-    """
-    for qatom in serializable_match._query_molecule.iterateAtoms():
-        atom = serializable_match.mapAtom(qatom)
-        if atom is None:
-            continue
-        atom.highlight()
-
-        for nei in atom.iterateNeighbors():
-            if not nei.isPseudoatom() and not nei.isRSite() and nei.atomicNumber() == 1:
-                nei.highlight()
-                nei.bond().highlight()
-
-    for bond in serializable_match._query_molecule.iterateBonds():
-        bond = serializable_match.mapBond(bond)
-        if bond is None:
-            continue
-        bond.highlight()
-
-
-def clear_highlights(molecule: IndigoObject):
-    """
-    Clear all highlights in the molecule.
-    :param molecule: The molecule to clear highlights from.
-    """
-    for atom in molecule.iterateAtoms():
-        atom.unhighlight()
-    for bond in molecule.iterateBonds():
-        bond.unhighlight()
-
-
-def clear_reaction_highlights(reaction: IndigoObject):
-    """
-    Clear all highlights in the reaction.
-    :param reaction: The reaction to clear highlights from.
-    """
-    for reactant in reaction.iterateReactants():
-        clear_highlights(reactant)
-    for product in reaction.iterateProducts():
-        clear_highlights(product)
-
-
-def reserve_atom_mapping_number_of_search_result(q_reaction: IndigoObject, q_reactant: IndigoObject,
-                                                 new_reaction_reactant: IndigoObject, new_reaction: IndigoObject,
-                                                 sub_match: SerializableMoleculeMatch) -> None:
-    """
-    Set the atom mapping number on the query molecule based on the atom mapping number of the sub_match molecule, if it exists.
-    :param new_reaction: The new reaction where the new reaction's reactant is found. This will be the target reaciton to write AAM to.
-    :param new_reaction_reactant: The new reaction's reactant where the AAM will be written to.
-    :param q_reactant: The query reactant from the query reaction that is being matched.
-    :param q_reaction: The query reaction that contains the query reactant for the sub_match.
-    :param sub_match: The substructure search match obtained from indigo.substructureMatcher(mol).match(query).
-    """
-    for query_atom in q_reactant.iterateAtoms():
-        concrete_atom = sub_match.mapAtom(query_atom)
-        if concrete_atom is None:
-            continue
-        reaction_atom = q_reactant.getAtom(query_atom.index())
-        map_num = q_reaction.atomMappingNumber(reaction_atom)
-        if map_num:
-            concrete_atom = new_reaction_reactant.getAtom(concrete_atom.index())
-            new_reaction.setAtomMappingNumber(concrete_atom, map_num)
-
-
-def clean_product_aam(reaction: IndigoObject):
-    """
-    Remove atom mappings from product that are not present in the reactants.
-    """
-    existing_mapping_numbers = set()
-    for reactant in reaction.iterateReactants():
-        for atom in reactant.iterateAtoms():
-            map_num = reaction.atomMappingNumber(atom)
-            if map_num:
-                existing_mapping_numbers.add(map_num)
-
-    for product in reaction.iterateProducts():
-        for atom in product.iterateAtoms():
-            map_num = reaction.atomMappingNumber(atom)
-            if map_num and map_num not in existing_mapping_numbers:
-                reaction.setAtomMappingNumber(atom, 0)  # YQ: atom number 0 means no mapping number in Indigo
-
-
-def make_concrete_reaction(reactants: list[IndigoObject], products: list[IndigoObject], replacement: IndigoObject,
-                           replacement_index: int) -> tuple[IndigoObject, IndigoObject]:
-    """
-    Create a concrete reaction from the given reactants and products, replacing the specified reactant with the replacement molecule.
-    :param reactants: List of reactant molecules.
-    :param products: List of product molecules.
-    :param replacement: The molecule to replace in the reactants.
-    :param replacement_index: The index of the reactant to replace.
-    :return: A new IndigoObject representing the concrete reaction.
-    """
-    concrete_reaction = indigo.createQueryReaction()
-    for i, reactant in enumerate(reactants):
-        if i == replacement_index:
-            concrete_reaction.addReactant(indigo.loadQueryMolecule(replacement.molfile()))
-        else:
-            concrete_reaction.addReactant(reactant.clone())
-    for product in products:
-        concrete_reaction.addProduct(product.clone())
-    return concrete_reaction, concrete_reaction.getMolecule(replacement_index)
-
-
-def is_ambiguous_atom(atom: IndigoObject) -> bool:
-    """
-    Test whether the symbol is an adjacent matching wildcard.
-    """
-    if atom.isPseudoatom() or atom.isRSite():
-        return True
-    symbol = atom.symbol()
-    if symbol in {'A', 'Q', 'X', 'M', 'AH', 'QH', 'XH', 'MH', 'NOT', 'R', '*'}:
-        return True
-    return "[" in symbol and "]" in symbol
-
-
-def get_react_site_highlights(product, ignored_atom_indexes):
-    """
-    Get the highlights for the reaction site in the product, ignoring the atoms that are not part of the reaction site.
-    :param product: The product molecule.
-    :param ignored_atom_indexes: A set of atom indexes to ignore.
-    :return: An IndigoObject with highlighted atoms and bonds that are part of the reaction site.
-    """
-    highlight = product.clone()
-    for atom in highlight.iterateAtoms():
-        if atom.index() not in ignored_atom_indexes:
-            atom.highlight()
-            for nei in atom.iterateNeighbors():
-                if nei.index() not in ignored_atom_indexes:
-                    nei.highlight()
-                    nei.bond().highlight()
-    return highlight
-
-
-def get_used_reactants_for_match(
-        reaction: IndigoObject, q_reaction: IndigoObject, reaction_match: IndigoObject,
-        kept_replacement_reaction_list_list: list[list[ReplacementReaction]]) -> list[ReplacementReaction]:
-    """
-    Find the replacement reactions that correspond to the reactants in reaction that also matches the query reaction.
-    Return None if any of the reactants do not have a corresponding replacement reaction, even though reaction may have matches directly to the query reaction.
-    Otherwise, return a list of ReplacementReaction objects that correspond to the reactants in the reaction ordered by the reactants in the query reaction.
-    """
-    q_reactants = []
-    for q_reactant in q_reaction.iterateReactants():
-        q_reactants.append(q_reactant)
-    q_products = []
-    for q_product in q_reaction.iterateProducts():
-        q_products.append(q_product)
-    reactants = []
-    for enum_r in reaction.iterateReactants():
-        reactants.append(enum_r)
-    products = []
-    for enum_p in reaction.iterateProducts():
-        products.append(enum_p)
-    ret: list[ReplacementReaction] = []
-    for i, q_reactant in enumerate(q_reactants):
-        replacement_list = kept_replacement_reaction_list_list[i]
-        enum_r = reactants[i]
-        useful_enumr_atom_indexes = set()
-        for rr_atom in q_reactant.iterateAtoms():
-            enum_atom = reaction_match.mapAtom(rr_atom)
-            if enum_atom:
-                useful_enumr_atom_indexes.add(enum_atom.index())
-        found: ReplacementReaction | None = None
-        for rr in replacement_list:
-            if found:
-                break
-            exact_match = indigo.exactMatch(enum_r, rr.replacement_reactant)
-            if not exact_match:
-                # YQ Skip if this enumeration is not meant to be the same reactant as replacement we are iterating.
-                continue
-            # YQ these are atoms in replacement reactant that are actually used in the query reactant
-            useful_rr_atom_indexes = set(rr.replacement_query_reaction_match._query_atom_to_atom.values())
-            useful_rr_neighbor_indexes = set()
-            # YQ furthermore, an atom is also considered useful for purpose of matching, if it neighbors a useful index, and is an ambiguous atom in query.
-            q_reactant: IndigoObject
-            for q_atom in q_reactant.iterateAtoms():
-                if is_ambiguous_atom(q_atom):
-                    for q_neighbor in q_atom.iterateNeighbors():
-                        mapped_atom = rr.replacement_query_reaction_match.mapAtom(q_neighbor)
-                        if mapped_atom:
-                            rr_atom_index = mapped_atom.index()
-                            useful_rr_neighbor_indexes.add(rr_atom_index)
-
-            useful_enum_r_mapping_numbers = set()
-            all_enum_r_mapping_numbers = set()
-            for enum_atom in enum_r.iterateAtoms():
-                enum_atom_index = enum_atom.index()
-                mapping_num = reaction.atomMappingNumber(enum_atom)
-                if mapping_num > 0:
-                    all_enum_r_mapping_numbers.add(mapping_num)
-                    # Assuming rr atom indexes are exact match to enum r.
-                    if enum_atom_index in useful_rr_atom_indexes:
-                        useful_enum_r_mapping_numbers.add(mapping_num)
-            ignoring_enum_r_mapping_numbers = all_enum_r_mapping_numbers - useful_enum_r_mapping_numbers - useful_rr_neighbor_indexes
-            all_products_match = True
-
-            rr_products = []
-            for rr_product in rr.reaction.iterateProducts():
-                rr_products.append(rr_product)
-            for j, product in enumerate(products):
-                q_product = rr_products[j]
-                product_matcher = indigo.substructureMatcher(product)
-                ignored_atom_indexes = set()
-                for enum_product_atom in product.iterateAtoms():
-                    enum_mapping_number = reaction.atomMappingNumber(enum_product_atom)
-                    # YQ For each atom in product: either it is not related to this reactant, or it must be inside the reactant site of the reactant.
-                    if enum_mapping_number in ignoring_enum_r_mapping_numbers:
-                        product_matcher.ignoreAtom(enum_product_atom)
-                        ignored_atom_indexes.add(enum_product_atom.index())
-                match = product_matcher.match(q_product)
-                if not match:
-                    all_products_match = False
-                else:
-                    found = rr
-
-            if all_products_match:
-                break
-        if found:
-            ret.append(found)
-        else:
-            return []
-    return ret
-
-
-def are_symmetrical_subs(match1: SerializableMoleculeMatch, match2: SerializableMoleculeMatch) -> bool:
-    """
-    Check if two SerializableMoleculeMatch objects are symmetrical.
-    That is, if we only get the atoms and bonds in the mapping, the two molecules are identical.
-    :param match1: The first SerializableMoleculeMatch object.
-    :param match2: The second SerializableMoleculeMatch object.
-    :return: True if the matches are symmetrical, False otherwise.
-    """
-    match1_test = match1.get_matched_molecule_copy()
-    match1_atom_indexes = set(match1._query_atom_to_atom.values())
-    match1_bond_indexes = set(match1._query_bond_to_bond.values())
-    atom_delete_list: list[int] = []
-    atom_mirror_list: list[int] = []
-    bond_delete_list: list[int] = []
-    bond_mirror_list: list[int] = []
-    for atom in match1_test.iterateAtoms():
-        if atom.index() not in match1_atom_indexes:
-            atom_delete_list.append(atom.index())
-        else:
-            atom_mirror_list.append(atom.index())
-    for bond in match1_test.iterateBonds():
-        if bond.index() not in match1_bond_indexes:
-            bond_delete_list.append(bond.index())
-        else:
-            bond_mirror_list.append(bond.index())
-    match1_test.removeBonds(bond_delete_list)
-    match1_test.removeAtoms(atom_delete_list)
-    match1_mirror_test = match1.get_matched_molecule_copy()
-    match1_mirror_test.removeBonds(bond_mirror_list)
-    match1_mirror_test.removeAtoms(atom_mirror_list)
-
-    match2_test = match2.get_matched_molecule_copy()
-    match2_atom_indexes = set(match2._query_atom_to_atom.values())
-    match2_bond_indexes = set(match2._query_bond_to_bond.values())
-    atom_delete_list = []
-    bond_delete_list = []
-    atom_mirror_list = []
-    bond_mirror_list = []
-    for atom in match2_test.iterateAtoms():
-        if atom.index() not in match2_atom_indexes:
-            atom_delete_list.append(atom.index())
-        else:
-            atom_mirror_list.append(atom.index())
-    for bond in match2_test.iterateBonds():
-        if bond.index() not in match2_bond_indexes:
-            bond_delete_list.append(bond.index())
-        else:
-            bond_mirror_list.append(bond.index())
-    match2_test.removeBonds(bond_delete_list)
-    match2_test.removeAtoms(atom_delete_list)
-    match2_mirror_test = match2.get_matched_molecule_copy()
-    match2_mirror_test.removeBonds(bond_mirror_list)
-    match2_mirror_test.removeAtoms(atom_mirror_list)
-
-    return match1_test.canonicalSmiles() == match2_test.canonicalSmiles() and \
-        match1_mirror_test.canonicalSmiles() == match2_mirror_test.canonicalSmiles()