rubin-sim 2.6.1.dev2__py3-none-any.whl

tests/phot_utils/test_snr.py

@@ -0,0 +1,370 @@
+import os
+import unittest
+
+import numpy as np
+from rubin_scheduler.data import get_data_dir
+
+import rubin_sim.phot_utils.signaltonoise as snr
+from rubin_sim.phot_utils import Bandpass, PhotometricParameters, Sed, scale_sky_m5
+
+
+class TestSNRmethods(unittest.TestCase):
+    def setUp(self):
+        star_name = os.path.join(get_data_dir(), "tests", "cartoonSedTestData", "starSed")
+        star_name = os.path.join(star_name, "kurucz", "km20_5750.fits_g40_5790.gz")
+        self.star_sed = Sed()
+        self.star_sed.read_sed_flambda(star_name)
+        imsimband = Bandpass()
+        imsimband.imsim_bandpass()
+        f_norm = self.star_sed.calc_flux_norm(22.0, imsimband)
+        self.star_sed.multiply_flux_norm(f_norm)
+
+        hardware_dir = os.path.join(get_data_dir(), "throughputs", "baseline")
+        component_list = [
+            "detector.dat",
+            "m1.dat",
+            "m2.dat",
+            "m3.dat",
+            "lens1.dat",
+            "lens2.dat",
+            "lens3.dat",
+        ]
+        self.sky_sed = Sed()
+        self.sky_sed.read_sed_flambda(os.path.join(hardware_dir, "darksky.dat"))
+
+        total_name_list = [
+            "total_u.dat",
+            "total_g.dat",
+            "total_r.dat",
+            "total_i.dat",
+            "total_z.dat",
+            "total_y.dat",
+        ]
+
+        self.bp_list = []
+        self.hardware_list = []
+        for name in total_name_list:
+            dummy = Bandpass()
+            dummy.read_throughput(os.path.join(hardware_dir, name))
+            self.bp_list.append(dummy)
+
+            dummy = Bandpass()
+            hardware_name_list = [os.path.join(hardware_dir, name)]
+            for component in component_list:
+                hardware_name_list.append(os.path.join(hardware_dir, component))
+            dummy.read_throughput_list(hardware_name_list)
+            self.hardware_list.append(dummy)
+
+        self.filter_name_list = ["u", "g", "r", "i", "z", "y"]
+
+        self.seeing_defaults = {
+            "u": 0.92,
+            "g": 0.87,
+            "r": 0.83,
+            "i": 0.80,
+            "z": 0.78,
+            "y": 0.76,
+        }
+
+    def test_mag_error(self):
+        """
+        Make sure that calc_mag_error_sed and calc_mag_error_m5
+        agree to within 0.001
+        """
+        phot_params = PhotometricParameters()
+
+        # create a cartoon spectrum to test on
+        spectrum = Sed()
+        spectrum.set_flat_sed()
+        spectrum.multiply_flux_norm(1.0e-9)
+
+        # find the magnitudes of that spectrum in our bandpasses
+        mag_list = []
+        for total in self.bp_list:
+            mag_list.append(spectrum.calc_mag(total))
+        mag_list = np.array(mag_list)
+
+        # try for different normalizations of the skySED
+        for f_norm in np.arange(1.0, 5.0, 1.0):
+            self.sky_sed.multiply_flux_norm(f_norm)
+
+            for total, hardware, filterName, mm in zip(
+                self.bp_list, self.hardware_list, self.filter_name_list, mag_list
+            ):
+                fwhm_eff = self.seeing_defaults[filterName]
+
+                m5 = snr.calc_m5(self.sky_sed, total, hardware, phot_params, fwhm_eff=fwhm_eff)
+
+                sigma_sed = snr.calc_mag_error_sed(
+                    spectrum,
+                    total,
+                    self.sky_sed,
+                    hardware,
+                    phot_params,
+                    fwhm_eff=fwhm_eff,
+                )
+
+                sigma_m5, gamma = snr.calc_mag_error_m5(mm, total, m5, phot_params)
+
+                self.assertAlmostEqual(sigma_m5, sigma_sed, 3)
+
+    def test_verbose_snr(self):
+        """
+        Make sure that calc_snr_sed has everything
+        it needs to run in verbose mode
+        """
+        phot_params = PhotometricParameters()
+
+        # create a cartoon spectrum to test on
+        spectrum = Sed()
+        spectrum.set_flat_sed()
+        spectrum.multiply_flux_norm(1.0e-9)
+
+        snr.calc_snr_sed(
+            spectrum,
+            self.bp_list[0],
+            self.sky_sed,
+            self.hardware_list[0],
+            phot_params,
+            fwhm_eff=0.7,
+            verbose=True,
+        )
+
+    def test_signal_to_noise(self):
+        """
+        Test that calc_snr_m5 and calc_snr_sed give similar results
+        """
+        phot_params = PhotometricParameters()
+
+        m5 = []
+        for i in range(len(self.hardware_list)):
+            m5.append(
+                snr.calc_m5(
+                    self.sky_sed,
+                    self.bp_list[i],
+                    self.hardware_list[i],
+                    phot_params,
+                    fwhm_eff=self.seeing_defaults[self.filter_name_list[i]],
+                )
+            )
+
+        sed_dir = os.path.join(get_data_dir(), "tests", "cartoonSedTestData/starSed/")
+        sed_dir = os.path.join(sed_dir, "kurucz")
+        file_name_list = os.listdir(sed_dir)
+
+        rng = np.random.RandomState(42)
+        offset = rng.random_sample(len(file_name_list)) * 2.0
+
+        for ix, name in enumerate(file_name_list):
+            if ix > 100:
+                break
+            spectrum = Sed()
+            spectrum.read_sed_flambda(os.path.join(sed_dir, name))
+            ff = spectrum.calc_flux_norm(m5[2] - offset[ix], self.bp_list[2])
+            spectrum.multiply_flux_norm(ff)
+            for i in range(len(self.bp_list)):
+                control_snr = snr.calc_snr_sed(
+                    spectrum,
+                    self.bp_list[i],
+                    self.sky_sed,
+                    self.hardware_list[i],
+                    phot_params,
+                    self.seeing_defaults[self.filter_name_list[i]],
+                )
+
+                mag = spectrum.calc_mag(self.bp_list[i])
+
+                test_snr, gamma = snr.calc_snr_m5(mag, self.bp_list[i], m5[i], phot_params)
+                self.assertLess((test_snr - control_snr) / control_snr, 0.001)
+
+    def test_systematic_uncertainty(self):
+        """
+        Test that systematic uncertainty is added correctly.
+        """
+        sigma_sys = 0.002
+        m5_list = [23.5, 24.3, 22.1, 20.0, 19.5, 21.7]
+        phot_params = PhotometricParameters(sigma_sys=sigma_sys)
+
+        magnitude_list = []
+        for bp in self.bp_list:
+            mag = self.star_sed.calc_mag(bp)
+            magnitude_list.append(mag)
+
+        for bp, hardware, filterName, mm, m5 in zip(
+            self.bp_list,
+            self.hardware_list,
+            self.filter_name_list,
+            magnitude_list,
+            m5_list,
+        ):
+            sky_dummy = Sed()
+            sky_dummy.read_sed_flambda(os.path.join(get_data_dir(), "throughputs", "baseline", "darksky.dat"))
+
+            normalized_sky_dummy = scale_sky_m5(
+                m5,
+                sky_dummy,
+                bp,
+                hardware,
+                fwhm_eff=self.seeing_defaults[filterName],
+                phot_params=phot_params,
+            )
+
+            sigma, gamma = snr.calc_mag_error_m5(mm, bp, m5, phot_params)
+
+            snrat = snr.calc_snr_sed(
+                self.star_sed,
+                bp,
+                normalized_sky_dummy,
+                hardware,
+                fwhm_eff=self.seeing_defaults[filterName],
+                phot_params=PhotometricParameters(),
+            )
+
+            test_snr, gamma = snr.calc_snr_m5(mm, bp, m5, phot_params=PhotometricParameters(sigma_sys=0.0))
+
+            self.assertAlmostEqual(
+                snrat,
+                test_snr,
+                10,
+                msg="failed on calc_snr_m5 test %e != %e " % (snrat, test_snr),
+            )
+
+            control = np.sqrt(np.power(snr.mag_error_from_snr(test_snr), 2) + np.power(sigma_sys, 2))
+
+            msg = "%e is not %e; failed" % (sigma, control)
+
+            self.assertAlmostEqual(sigma, control, 10, msg=msg)
+
+    def test_no_systematic_uncertainty(self):
+        """
+        Test that systematic uncertainty is handled correctly
+        when set to None.
+        """
+        m5_list = [23.5, 24.3, 22.1, 20.0, 19.5, 21.7]
+        phot_params = PhotometricParameters(sigma_sys=0.0)
+
+        magnitude_list = []
+        for bp in self.bp_list:
+            mag = self.star_sed.calc_mag(bp)
+            magnitude_list.append(mag)
+
+        for bp, hardware, filterName, mm, m5 in zip(
+            self.bp_list,
+            self.hardware_list,
+            self.filter_name_list,
+            magnitude_list,
+            m5_list,
+        ):
+            sky_dummy = Sed()
+            sky_dummy.read_sed_flambda(os.path.join(get_data_dir(), "throughputs", "baseline", "darksky.dat"))
+
+            normalized_sky_dummy = scale_sky_m5(
+                m5,
+                sky_dummy,
+                bp,
+                hardware,
+                fwhm_eff=self.seeing_defaults[filterName],
+                phot_params=phot_params,
+            )
+
+            sigma, gamma = snr.calc_mag_error_m5(mm, bp, m5, phot_params)
+
+            snrat = snr.calc_snr_sed(
+                self.star_sed,
+                bp,
+                normalized_sky_dummy,
+                hardware,
+                fwhm_eff=self.seeing_defaults[filterName],
+                phot_params=PhotometricParameters(),
+            )
+
+            test_snr, gamma = snr.calc_snr_m5(mm, bp, m5, phot_params=PhotometricParameters(sigma_sys=0.0))
+
+            self.assertAlmostEqual(
+                snrat,
+                test_snr,
+                10,
+                msg="failed on calc_snr_m5 test %e != %e " % (snrat, test_snr),
+            )
+
+            control = snr.mag_error_from_snr(test_snr)
+
+            msg = "%e is not %e; failed" % (sigma, control)
+
+            self.assertAlmostEqual(sigma, control, 10, msg=msg)
+
+    def test_fwh_mconversions(self):
+        fwhm_eff = 0.8
+        fwh_mgeom = snr.fwhm_eff2_fwhm_geom(fwhm_eff)
+        self.assertEqual(fwh_mgeom, (0.822 * fwhm_eff + 0.052))
+        fwh_mgeom = 0.8
+        fwhm_eff = snr.fwhm_geom2_fwhm_eff(fwh_mgeom)
+        self.assertEqual(fwhm_eff, (fwh_mgeom - 0.052) / 0.822)
+
+    def test_astrometric_error(self):
+        fwhm_geom = 0.7
+        m5 = 24.5
+        # For bright objects, error should be systematic floor
+        mag = 10
+        astrometric_err = snr.calc_astrometric_error(
+            mag, m5, fwhm_geom=fwhm_geom, nvisit=1, systematic_floor=10
+        )
+        self.assertAlmostEqual(astrometric_err, 10, 3)
+        # Even if you increase the number of visits,
+        # the systemic floor doesn't change
+        astrometric_err = snr.calc_astrometric_error(mag, m5, fwhm_geom=fwhm_geom, nvisit=100)
+        self.assertAlmostEqual(astrometric_err, 10, 3)
+        # For a single visit, fainter source, larger error and nvisits matters
+        mag = 24.5
+        astrometric_err1 = snr.calc_astrometric_error(
+            mag, m5, fwhm_geom=fwhm_geom, nvisit=1, systematic_floor=10
+        )
+        astrometric_err100 = snr.calc_astrometric_error(
+            mag, m5, fwhm_geom=fwhm_geom, nvisit=100, systematic_floor=10
+        )
+        self.assertGreater(astrometric_err1, astrometric_err100)
+        self.assertAlmostEqual(astrometric_err1, 140.357, 3)
+
+    def test_snr_arr(self):
+        """
+        Test that calc_snr_m5 works on numpy arrays of magnitudes
+        """
+        rng = np.random.RandomState(17)
+        mag_list = rng.random_sample(100) * 5.0 + 15.0
+
+        phot_params = PhotometricParameters()
+        bp = self.bp_list[0]
+        m5 = 24.0
+        control_list = []
+        for mm in mag_list:
+            ratio, gamma = snr.calc_snr_m5(mm, bp, m5, phot_params)
+            control_list.append(ratio)
+        control_list = np.array(control_list)
+
+        test_list, gamma = snr.calc_snr_m5(mag_list, bp, m5, phot_params)
+
+        np.testing.assert_array_equal(control_list, test_list)
+
+    def test_error_arr(self):
+        """
+        Test that calc_mag_error_m5 works on numpy arrays of magnitudes
+        """
+        rng = np.random.RandomState(17)
+        mag_list = rng.random_sample(100) * 5.0 + 15.0
+
+        phot_params = PhotometricParameters()
+        bp = self.bp_list[0]
+        m5 = 24.0
+        control_list = []
+        for mm in mag_list:
+            sig, gamma = snr.calc_mag_error_m5(mm, bp, m5, phot_params)
+            control_list.append(sig)
+        control_list = np.array(control_list)
+
+        test_list, gamma = snr.calc_mag_error_m5(mag_list, bp, m5, phot_params)
+
+        np.testing.assert_array_equal(control_list, test_list)
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/satellite_constellations/test_satellites.py

@@ -0,0 +1,36 @@
+import unittest
+
+import numpy as np
+from rubin_scheduler.utils import SURVEY_START_MJD
+
+from rubin_sim.satellite_constellations import Constellation, oneweb_tles, starlink_tles_v1, starlink_tles_v2
+
+
+class TestSatellites(unittest.TestCase):
+    def test_constellations(self):
+        """Test stellite constellations"""
+
+        mjd0 = SURVEY_START_MJD
+        sv1 = starlink_tles_v1()
+        sv2 = starlink_tles_v2()
+        onw = oneweb_tles()
+
+        assert sv1 is not None
+        assert sv2 is not None
+        assert onw is not None
+
+        const = Constellation(sv1)
+
+        lengths, n_s = const.check_pointings(
+            np.array([85.0, 82.0]),
+            np.array([0.0, 0.0]),
+            np.arange(2) + mjd0 + 1.5,
+            30.0,
+        )
+
+        assert np.size(lengths) == 2
+        assert np.size(n_s) == 2
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/sim_archive/test_make_snapshot.py

@@ -0,0 +1,24 @@
+import importlib.util
+import unittest
+
+from rubin_scheduler.scheduler.schedulers.core_scheduler import CoreScheduler
+
+if importlib.util.find_spec("lsst"):
+    HAVE_TS = importlib.util.find_spec("lsst.ts")
+else:
+    HAVE_TS = False
+
+if HAVE_TS:
+    from rubin_sim.sim_archive import get_scheduler_instance_from_repo
+
+
+class TestMakeSnapshot(unittest.TestCase):
+    @unittest.skip("Skipping because test depends on external repo.")
+    @unittest.skipIf(not HAVE_TS, "No lsst.ts")
+    def test_get_scheduler_instance_photcal(self):
+        scheduler = get_scheduler_instance_from_repo(
+            config_repo="https://github.com/lsst-ts/ts_config_ocs.git",
+            config_script="Scheduler/feature_scheduler/auxtel/fbs_config_image_photocal_survey.py",
+            config_branch="main",
+        )
+        self.assertIsInstance(scheduler, CoreScheduler)

tests/sim_archive/test_prototype_sim_archive.py

@@ -0,0 +1,204 @@
+import importlib
+import lzma
+import os
+import pickle
+import unittest
+import urllib
+from pathlib import Path
+from tempfile import TemporaryDirectory
+
+import numpy as np
+import pandas as pd
+from astropy.time import Time
+from rubin_scheduler.scheduler import sim_runner
+from rubin_scheduler.scheduler.example import example_scheduler
+from rubin_scheduler.scheduler.model_observatory import ModelObservatory
+from rubin_scheduler.utils import SURVEY_START_MJD
+
+HAVE_LSST_RESOURCES = importlib.util.find_spec("lsst") and importlib.util.find_spec("lsst.resources")
+HAVE_AWS_CREDENTIALS = "AWS_SHARED_CREDENTIALS_FILE" in os.environ and os.path.isfile(
+    os.environ["AWS_SHARED_CREDENTIALS_FILE"]
+)
+
+if HAVE_LSST_RESOURCES:
+    from lsst.resources import ResourcePath
+
+    from rubin_sim.sim_archive.prototype import (
+        check_opsim_archive_resource,
+        compile_sim_metadata,
+        fetch_obsloctap_visits,
+        fetch_sim_for_nights,
+        fetch_sim_stats_for_night,
+        find_latest_prenight_sim_for_nights,
+        make_sim_archive_cli,
+        make_sim_archive_dir,
+        read_archived_sim_metadata,
+        read_sim_metadata_from_hdf,
+        transfer_archive_dir,
+        verify_compiled_sim_metadata,
+    )
+
+
+class TestPrototypeSimArchive(unittest.TestCase):
+    def setUp(self) -> None:
+        self.start_environ: dict = {}
+        self.start_environ.update(os.environ)
+        os.environ["LSST_DISABLE_BUCKET_VALIDATION"] = "1"
+
+    def tearDown(self) -> None:
+        for key in os.environ:
+            if key not in self.start_environ:
+                del os.environ[key]
+            else:
+                if os.environ[key] != self.start_environ[key]:
+                    os.environ[key] = self.start_environ[key]
+
+    @unittest.skipIf(not HAVE_LSST_RESOURCES, "No lsst.resources")
+    def test_sim_archive(self) -> None:
+        # Begin by running a short simulation
+        sim_start_mjd = SURVEY_START_MJD
+        sim_duration = 1  # days
+        scheduler = example_scheduler(mjd_start=sim_start_mjd)
+        scheduler.keep_rewards = True
+        observatory = ModelObservatory(mjd_start=sim_start_mjd)
+
+        # Record the state of the scheduler at the start of the sim.
+        data_dir = TemporaryDirectory()
+        data_path = Path(data_dir.name)
+
+        scheduler_fname = data_path.joinpath("scheduler.pickle.xz")
+        with lzma.open(scheduler_fname, "wb", format=lzma.FORMAT_XZ) as pio:
+            pickle.dump(scheduler, pio)
+
+        files_to_archive = {"scheduler": scheduler_fname}
+
+        # Run the simulation
+        sim_runner_kwargs = {
+            "sim_start_mjd": sim_start_mjd,
+            "sim_duration": sim_duration,
+            "record_rewards": True,
+        }
+
+        observatory, scheduler, observations, reward_df, obs_rewards = sim_runner(
+            observatory, scheduler, **sim_runner_kwargs
+        )
+
+        # Make the scratch sim archive
+        make_sim_archive_dir(
+            observations,
+            reward_df=reward_df,
+            obs_rewards=obs_rewards,
+            in_files=files_to_archive,
+            sim_runner_kwargs=sim_runner_kwargs,
+            tags=["test"],
+            label="test",
+            data_path=data_path,
+        )
+
+        # Move the scratch sim archive to a test resource
+        test_resource_dir = TemporaryDirectory()
+        test_resource_uri = "file://" + test_resource_dir.name
+        sim_archive_uri = transfer_archive_dir(data_dir.name, test_resource_uri)
+
+        # Check the saved archive
+        archive_check = check_opsim_archive_resource(sim_archive_uri)
+        for value in archive_check.values():
+            self.assertTrue(value)
+
+        # Read back the metadata
+        archive_metadata = read_archived_sim_metadata(test_resource_uri)
+        base = sim_archive_uri.dirname().geturl().removeprefix(test_resource_uri).rstrip("/").lstrip("/")
+        expected_label = f"{base} test"
+        self.assertEqual(archive_metadata[sim_archive_uri.geturl()]["label"], expected_label)
+
+        # Cache the metadata
+        test_compiled_metadata_uri = test_resource_uri + "/compiled_metadata_cache.h5"
+
+        # Test reading from cached metadata
+        compile_sim_metadata(test_resource_uri, test_compiled_metadata_uri)
+        read_sim_metadata_from_hdf(test_compiled_metadata_uri)
+        read_archived_sim_metadata(test_resource_uri, compilation_resource=test_compiled_metadata_uri)
+        verify_compiled_sim_metadata(test_resource_uri, test_compiled_metadata_uri)
+
+    @unittest.skipIf(not HAVE_LSST_RESOURCES, "No lsst.resources")
+    @unittest.skipIf(importlib.util.find_spec("schedview") is None, "No schedview")
+    def test_cli(self) -> None:
+        test_resource_path = ResourcePath("resource://schedview/data/")
+        with test_resource_path.join("sample_opsim.db").as_local() as local_rp:
+            opsim = urllib.parse.urlparse(local_rp.geturl()).path
+
+        with test_resource_path.join("sample_rewards.h5").as_local() as local_rp:
+            rewards = urllib.parse.urlparse(local_rp.geturl()).path
+
+        with test_resource_path.join("sample_scheduler.pickle.xz").as_local() as local_rp:
+            scheduler = urllib.parse.urlparse(local_rp.geturl()).path
+
+        with TemporaryDirectory() as test_archive_dir:
+            test_archive_uri = f"file://{test_archive_dir}/"
+            make_sim_archive_cli(
+                "Test",
+                opsim,
+                "--rewards",
+                rewards,
+                "--scheduler",
+                scheduler,
+                "--archive_base_uri",
+                test_archive_uri,
+            )
+
+    @unittest.skipIf(not HAVE_LSST_RESOURCES, "No lsst.resources")
+    @unittest.skipIf(not HAVE_AWS_CREDENTIALS, "No credentials")
+    def test_find_latest_prenight_sim_for_night(self) -> None:
+        day_obs = "2025-09-25"
+        max_simulation_age = int(np.ceil(Time.now().mjd - Time(day_obs).mjd)) + 1
+        sim_metadata = find_latest_prenight_sim_for_nights(day_obs, max_simulation_age=max_simulation_age)
+        assert sim_metadata["simulated_dates"]["first"] <= day_obs <= sim_metadata["simulated_dates"]["last"]
+
+    @unittest.skipIf(not HAVE_LSST_RESOURCES, "No lsst.resources")
+    @unittest.skipIf(not HAVE_AWS_CREDENTIALS, "No credentials")
+    def test_fetch_sim_for_nights(self) -> None:
+        day_obs = "2025-09-25"
+        max_simulation_age = int(np.ceil(Time.now().mjd - Time(day_obs).mjd)) + 1
+        visits = fetch_sim_for_nights(day_obs, which_sim={"max_simulation_age": max_simulation_age})
+        assert len(visits) > 0
+
+    @unittest.skipIf(not HAVE_LSST_RESOURCES, "No lsst.resources")
+    @unittest.skipIf(not HAVE_AWS_CREDENTIALS, "No credentials")
+    def test_fetch_obsloctap_visits(self) -> None:
+        day_obs = "2025-09-25"
+        num_nights = 2
+        visits = pd.DataFrame(fetch_obsloctap_visits(day_obs, nights=num_nights))
+        assert 500 < len(visits) / num_nights < 1500
+
+        assert np.all(np.isfinite(visits["observationStartMJD"]))
+        assert np.floor(visits["observationStartMJD"].min() - 0.5) == Time(day_obs).mjd
+        assert np.floor(visits["observationStartMJD"].max() - 0.5) == Time(day_obs).mjd + num_nights - 1
+
+        assert np.all(np.isfinite(visits["fieldDec"]))
+        assert visits["fieldDec"].min() >= -90.0
+        assert visits["fieldDec"].max() <= 90.0
+
+        assert np.all(np.isfinite(visits["rotSkyPos"]))
+        assert visits["rotSkyPos"].min() >= -720.0
+        assert visits["rotSkyPos"].max() <= 720.0
+
+        assert np.all(np.isfinite(visits["visitExposureTime"]))
+        assert visits["visitExposureTime"].min() >= -720.0
+        assert visits["visitExposureTime"].max() <= 720.0
+
+        assert "band" in visits.columns
+        assert "target_name" in visits.columns
+
+    @unittest.skipIf(not HAVE_LSST_RESOURCES, "No lsst.resources")
+    @unittest.skipIf(not HAVE_AWS_CREDENTIALS, "No credentials")
+    def test_fetch_sim_stats_for_night(self) -> None:
+        day_obs = "2025-09-12"
+        num_visits = fetch_sim_stats_for_night(day_obs)["nominal_visits"]
+        assert num_visits > 0
+
+        # Make sure it runs with a default day_obs
+        fetch_sim_stats_for_night()
+
+
+if __name__ == "__main__":
+    unittest.main()