Merge branch 'main' into performance-optimization-list-append-15142826470891655336

Author: mhucka

.github/workflows/ci.yaml

@@ -114,31 +114,24 @@ jobs:
           # The outputs will be variables named "foo_files" for a filter "foo".
           filters: |
             ci:
-              - './.github/workflows/**'
-              - './check/**'
-              - './dev_tools/**'
+              - '.github/workflows/**'
+              - 'check/**'
+              - 'dev_tools/**'
             python:
               - '**/*.py'
               - 'dev_tools/conf/**'
               - 'dev_tools/requirements/**/*.txt'
               - 'docs/**/*-requirements.txt'
-              - 'docs/**/requirements.txt'
               - 'pyproject.toml'
             gha:
-              - added|modified:
-                  - './.github/workflows/*.yaml'
+              - '.github/workflows/*.yaml'
             yaml:
-              - added|modified:
-                  - '*.cff'
-                  - '.*.yaml'
-                  - '.github/*.yaml'
-                  - 'docs/**/*.yaml'
+              - '*.cff'
+              - '**/*.yaml'
             json:
-              - added|modified:
-                  - '**/*.json'
+              - '**/*.json'
             docker:
-              - '**/dockerfile'
-              - '**/Dockerfile'
+              - '**/[Dd]ockerfile'
             shell:
               - '**/*.sh'
               - 'check/*'

dev_tools/prepared_env.py

@@ -97,14 +97,14 @@ def report_status_to_github(
         if target_url is not None:
             payload['target_url'] = target_url
 
-        url = "https://api.github.com/repos/{}/{}/statuses/{}?access_token={}".format(
-            self.repository.organization,
-            self.repository.name,
-            self.actual_commit_id,
-            self.repository.access_token,
+        if self.actual_commit_id is None:
+            return
+        url = "https://api.github.com/repos/{}/{}/statuses/{}".format(
+            self.repository.organization, self.repository.name, self.actual_commit_id
         )
+        headers = {'Authorization': 'Bearer {}'.format(self.repository.access_token)}
 
-        response = requests.post(url, json=payload)
+        response = requests.post(url, json=payload, headers=headers, timeout=30)
 
         if response.status_code != 201:
             raise IOError(

dev_tools/prepared_env_security_test.py

@@ -0,0 +1,38 @@
+import unittest
+from unittest.mock import patch, MagicMock
+from dev_tools.prepared_env import PreparedEnv
+from dev_tools.github_repository import GithubRepository
+
+
+class TestPreparedEnvSecurity(unittest.TestCase):
+    @patch('requests.post')
+    def test_report_status_to_github_token_in_header(self, mock_post):
+        # Setup
+        mock_response = MagicMock()
+        mock_response.status_code = 201
+        mock_post.return_value = mock_response
+
+        repo = GithubRepository('my-org', 'my-repo', 'my-token')
+        env = PreparedEnv(repo, 'my-commit', 'compare-commit', None, None)
+
+        # Execute
+        env.report_status_to_github('success', 'desc', 'ctx')
+
+        # Verify
+        args, kwargs = mock_post.call_args
+        url = args[0]
+        headers = kwargs.get('headers', {})
+
+        # Security check: Token should NOT be in the URL
+        self.assertNotIn('access_token=my-token', url, "Token should not be passed in the URL")
+
+        # Security check: Token should be in the Authorization header
+        self.assertEqual(
+            headers.get('Authorization'),
+            'Bearer my-token',
+            "Token should be passed in the Authorization header",
+        )
+
+
+if __name__ == '__main__':
+    unittest.main()

src/openfermion/chem/pubchem_test.py

@@ -12,12 +12,9 @@
 
 """Tests for pubchem.py."""
 
-import time
-import unittest
-from unittest.mock import patch
-
 import numpy
 import pytest
+import pubchempy
 
 from openfermion.chem.pubchem import geometry_from_pubchem
 from openfermion.testing.testing_utils import module_importable
@@ -79,24 +76,24 @@ def mock_get_compounds(name, searchtype, record_type='2d'):
 
 
 @using_pubchempy
-class OpenFermionPubChemTest(unittest.TestCase):
+class TestOpenFermionPubChem:
 
-    @patch('pubchempy.get_compounds', mock_get_compounds)
-    def test_water(self):
+    def test_water(self, monkeypatch):
+        monkeypatch.setattr(pubchempy, 'get_compounds', mock_get_compounds)
         water_geometry = geometry_from_pubchem('water')
-        self.water_natoms = len(water_geometry)
-        self.water_atoms = [water_atom[0] for water_atom in water_geometry]
-        water_oxygen_index = self.water_atoms.index('O')
+        water_natoms_actual = len(water_geometry)
+        water_atoms = [water_atom[0] for water_atom in water_geometry]
+        water_oxygen_index = water_atoms.index('O')
         water_oxygen = water_geometry.pop(water_oxygen_index)
         water_oxygen_coordinate = numpy.array(water_oxygen[1])
         water_hydrogen1_coordinate = numpy.array(water_geometry[0][1])
         water_hydrogen2_coordinate = numpy.array(water_geometry[1][1])
         water_oxygen_hydrogen1 = water_hydrogen1_coordinate - water_oxygen_coordinate
         water_oxygen_hydrogen2 = water_hydrogen2_coordinate - water_oxygen_coordinate
 
-        self.water_bond_length_1 = numpy.linalg.norm(water_oxygen_hydrogen1)
-        self.water_bond_length_2 = numpy.linalg.norm(water_oxygen_hydrogen2)
-        self.water_bond_angle = numpy.arccos(
+        water_bond_length_1 = numpy.linalg.norm(water_oxygen_hydrogen1)
+        water_bond_length_2 = numpy.linalg.norm(water_oxygen_hydrogen2)
+        water_bond_angle = numpy.arccos(
             numpy.dot(
                 water_oxygen_hydrogen1,
                 water_oxygen_hydrogen2
@@ -108,51 +105,51 @@ def test_water(self):
         )
 
         water_natoms = 3
-        self.assertEqual(water_natoms, self.water_natoms)
+        assert water_natoms == water_natoms_actual
 
-        self.assertAlmostEqual(self.water_bond_length_1, self.water_bond_length_2, places=4)
+        assert water_bond_length_1 == pytest.approx(water_bond_length_2, abs=1e-4)
         water_bond_length_low = 0.9
         water_bond_length_high = 1.1
-        self.assertTrue(water_bond_length_low <= self.water_bond_length_1)
-        self.assertTrue(water_bond_length_high >= self.water_bond_length_1)
+        assert water_bond_length_low <= water_bond_length_1
+        assert water_bond_length_high >= water_bond_length_1
 
         water_bond_angle_low = 100.0 / 360 * 2 * numpy.pi
         water_bond_angle_high = 110.0 / 360 * 2 * numpy.pi
-        self.assertTrue(water_bond_angle_low <= self.water_bond_angle)
-        self.assertTrue(water_bond_angle_high >= self.water_bond_angle)
+        assert water_bond_angle_low <= water_bond_angle
+        assert water_bond_angle_high >= water_bond_angle
 
-    @patch('pubchempy.get_compounds', mock_get_compounds)
-    def test_helium(self):
+    def test_helium(self, monkeypatch):
+        monkeypatch.setattr(pubchempy, 'get_compounds', mock_get_compounds)
         helium_geometry = geometry_from_pubchem('helium')
-        self.helium_natoms = len(helium_geometry)
+        helium_natoms_actual = len(helium_geometry)
 
         helium_natoms = 1
-        self.assertEqual(helium_natoms, self.helium_natoms)
+        assert helium_natoms == helium_natoms_actual
 
-    @patch('pubchempy.get_compounds', mock_get_compounds)
-    def test_none(self):
+    def test_none(self, monkeypatch):
+        monkeypatch.setattr(pubchempy, 'get_compounds', mock_get_compounds)
         none_geometry = geometry_from_pubchem('none')
 
-        self.assertIsNone(none_geometry)
+        assert none_geometry is None
 
-    @patch('pubchempy.get_compounds', mock_get_compounds)
-    def test_water_2d(self):
+    def test_water_2d(self, monkeypatch):
+        monkeypatch.setattr(pubchempy, 'get_compounds', mock_get_compounds)
         water_geometry = geometry_from_pubchem('water', structure='2d')
-        self.water_natoms = len(water_geometry)
+        water_natoms_actual = len(water_geometry)
 
         water_natoms = 3
-        self.assertEqual(water_natoms, self.water_natoms)
+        assert water_natoms == water_natoms_actual
 
-        self.oxygen_z_1 = water_geometry[0][1][2]
-        self.oxygen_z_2 = water_geometry[1][1][2]
+        oxygen_z_1 = water_geometry[0][1][2]
+        oxygen_z_2 = water_geometry[1][1][2]
         z = 0
-        self.assertEqual(z, self.oxygen_z_1)
-        self.assertEqual(z, self.oxygen_z_2)
+        assert z == oxygen_z_1
+        assert z == oxygen_z_2
 
         with pytest.raises(ValueError, match='Incorrect value for the argument structure'):
             _ = geometry_from_pubchem('water', structure='foo')
 
-    @pytest.mark.flaky(retries=3, delay=2)
+    @pytest.mark.flaky(retries=3, delay=2, only_on=[pubchempy.ServerBusyError])
     def test_geometry_from_pubchem_live_api(self):
-        water_geometry = geometry_from_pubchem('water')  # pragma: no cover
-        self.assertEqual(len(water_geometry), 3)  # pragma: no cover
+        water_geometry = geometry_from_pubchem('water')
+        assert len(water_geometry) == 3

src/openfermion/ops/operators/binary_code.py

@@ -19,8 +19,6 @@
 
 from openfermion.ops.operators import BinaryPolynomial
 
-# import openfermion.ops.operators._binary_polynomial as bp
-
 
 def shift_decoder(decoder, shift_constant):
     """Shifts the indices of a decoder by a constant.

src/openfermion/utils/commutators_test.py

@@ -217,6 +217,38 @@ def test_double_commtator_more_info_both_hopping(self):
             com, (FermionOperator('4^ 3^ 4 2', 2.73) + FermionOperator('4^ 2^ 4 3', 2.73))
         )
 
+    def test_double_commutator_hopping_no_intersection(self):
+        # Case where intersection is empty
+        op1 = FermionOperator('0^ 0')
+        op2 = FermionOperator('1^ 2') + FermionOperator('2^ 1')
+        op3 = FermionOperator('3^ 4') + FermionOperator('4^ 3')
+        res = double_commutator(
+            op1,
+            op2,
+            op3,
+            indices2={1, 2},
+            indices3={3, 4},
+            is_hopping_operator2=True,
+            is_hopping_operator3=True,
+        )
+        self.assertEqual(res, FermionOperator.zero())
+
+    def test_double_commutator_hopping_multi_intersection(self):
+        # Case where intersection has more than one element
+        op1 = FermionOperator('0^ 0')
+        op2 = FermionOperator('1^ 2') + FermionOperator('2^ 1')
+        op3 = FermionOperator('1^ 2') + FermionOperator('2^ 1')
+        res = double_commutator(
+            op1,
+            op2,
+            op3,
+            indices2={1, 2},
+            indices3={1, 2},
+            is_hopping_operator2=True,
+            is_hopping_operator3=True,
+        )
+        self.assertEqual(res, FermionOperator.zero())
+
 
 class TriviallyDoubleCommutesDualBasisUsingTermInfoTest(unittest.TestCase):
     def test_number_operators_trivially_commute(self):