cabaret 0.0.6__tar.gz

cabaret-0.0.6/.gitattributes

@@ -0,0 +1,2 @@
+# Auto detect text files and perform LF normalization
+* text=auto

cabaret-0.0.6/.github/workflows/publish.yml

@@ -0,0 +1,52 @@
+name: cabaret/build-publish
+
+on:
+  push:
+    branches:
+      - main
+    tags:
+      - "*"
+  pull_request:
+  merge_group:
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+      - uses: actions/setup-python@v5
+        name: Install Python
+        with:
+          python-version: "3.10"
+      - name: Install dependencies
+        run: |
+          python -m pip install -U pip
+          python -m pip install -U build twine
+      - name: Build the distribution
+        run: python -m build .
+      - name: Check the distribution
+        run: python -m twine check --strict dist/*
+      - uses: actions/upload-artifact@v4
+        with:
+          name: dist
+          path: dist/*
+
+  publish:
+    environment:
+      name: pypi
+      url: https://pypi.org/p/cabaret
+    permissions:
+      contents: read
+      id-token: write
+    needs: [build]
+    runs-on: ubuntu-latest
+    if: github.event_name == 'push' && startsWith(github.ref, 'refs/tags/')
+    steps:
+      - uses: actions/download-artifact@v4
+        with:
+          name: dist
+          path: dist
+      - uses: pypa/gh-action-pypi-publish@v1.8.11
+  

cabaret-0.0.6/.gitignore

@@ -0,0 +1,160 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# poetry
+#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
+#poetry.lock
+
+# pdm
+#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
+#pdm.lock
+#   pdm stores project-wide configurations in .pdm.toml, but it is recommended to not include it
+#   in version control.
+#   https://pdm.fming.dev/#use-with-ide
+.pdm.toml
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# PyCharm
+#  JetBrains specific template is maintained in a separate JetBrains.gitignore that can
+#  be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
+#  and can be added to the global gitignore or merged into this file.  For a more nuclear
+#  option (not recommended) you can uncomment the following to ignore the entire idea folder.
+#.idea/

cabaret-0.0.6/.vscode/settings.json

@@ -0,0 +1,15 @@
+{
+    "editor.formatOnSave": true,
+    "[python]": {
+        "editor.codeActionsOnSave": {
+            "source.organizeImports": "explicit"
+        },
+        "editor.formatOnPaste": false,
+        "editor.defaultFormatter": "ms-python.black-formatter"
+    },
+    "python.testing.pytestArgs": [
+        "tests"
+    ],
+    "python.testing.unittestEnabled": false,
+    "python.testing.pytestEnabled": true
+}

cabaret-0.0.6/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Peter Pihlmann Pedersen
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

cabaret-0.0.6/PKG-INFO

@@ -0,0 +1,77 @@
+Metadata-Version: 2.3
+Name: cabaret
+Version: 0.0.6
+Author: Peter Pedersen, Lionel Garcia
+License: MIT License
+License-File: LICENSE
+Requires-Python: >=3.9
+Requires-Dist: astropy
+Requires-Dist: astroquery
+Requires-Dist: numpy
+Provides-Extra: dev
+Requires-Dist: black; extra == 'dev'
+Requires-Dist: pytest; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# cabaret
+![](example.jpg)
+*cabaret* is a Python package to simulate astronomical images using the [GAIA catalog](https://en.wikipedia.org/wiki/Gaia_catalogues) of stars.
+## Installation
+
+You can install *cabaret* in a Python (`>=3.9`) environment with
+
+```bash
+pip install cabaret
+```
+
+or from a local clone
+
+```bash
+git clone https://github.com/ppp-one/cabaret
+pip install -e cabaret
+```
+
+You can test the package has been properly installed with
+
+```bash
+python -c "import cabaret"
+```
+
+## Example
+
+### Basic image 
+
+To generate an image from RA/DEC coordinates and a field of vue specified in degrees:
+
+```python
+import cabaret
+
+ra, dec = 12.3323, 30.4343 # in degrees
+exposure_time = 10 # in seconds
+
+image = cabaret.generate_image(ra, dec, exposure_time)
+```
+
+and to display the image (`matplotlib` required here):
+
+```python
+import matplotlib.pyplot as plt
+
+plt.imshow(image)
+```
+
+### Using the camera characteristics
+
+To  adjust the physical characteristics of the camera, you can define and pass a `Camera` object
+
+```python
+import cabaret
+from cabaret import Camera
+
+camera = Camera(read_noise=10, gain=1)
+
+ra, dec = 12.3323, 30.4343 # in degrees
+exposure_time = 10 # in seconds
+
+image = cabaret.generate_image(ra, dec, exposure_time, camera=camera)
+``` 

cabaret-0.0.6/README.md

@@ -0,0 +1,62 @@
+# cabaret
+![](example.jpg)
+*cabaret* is a Python package to simulate astronomical images using the [GAIA catalog](https://en.wikipedia.org/wiki/Gaia_catalogues) of stars.
+## Installation
+
+You can install *cabaret* in a Python (`>=3.9`) environment with
+
+```bash
+pip install cabaret
+```
+
+or from a local clone
+
+```bash
+git clone https://github.com/ppp-one/cabaret
+pip install -e cabaret
+```
+
+You can test the package has been properly installed with
+
+```bash
+python -c "import cabaret"
+```
+
+## Example
+
+### Basic image 
+
+To generate an image from RA/DEC coordinates and a field of vue specified in degrees:
+
+```python
+import cabaret
+
+ra, dec = 12.3323, 30.4343 # in degrees
+exposure_time = 10 # in seconds
+
+image = cabaret.generate_image(ra, dec, exposure_time)
+```
+
+and to display the image (`matplotlib` required here):
+
+```python
+import matplotlib.pyplot as plt
+
+plt.imshow(image)
+```
+
+### Using the camera characteristics
+
+To  adjust the physical characteristics of the camera, you can define and pass a `Camera` object
+
+```python
+import cabaret
+from cabaret import Camera
+
+camera = Camera(read_noise=10, gain=1)
+
+ra, dec = 12.3323, 30.4343 # in degrees
+exposure_time = 10 # in seconds
+
+image = cabaret.generate_image(ra, dec, exposure_time, camera=camera)
+``` 

cabaret-0.0.6/pyproject.toml

@@ -0,0 +1,22 @@
+[project]
+name = "cabaret"
+version = "0.0.6"
+authors = [
+  {name = "Peter Pedersen"},
+  {name = "Lionel Garcia"},
+]
+repository = "https://github.com/ppp-one/cabaret"
+readme = "README.md"
+license = { text = "MIT License" }
+requires-python = ">=3.9"
+dependencies = ["numpy", "astropy", "astroquery"]
+
+[build-system]
+requires = ["hatchling", "hatch-vcs"]
+build-backend = "hatchling.build"
+
+[tool.hatch.version]
+source = "vcs"
+
+[project.optional-dependencies]
+dev = ["black", "pytest"]

cabaret-0.0.6/src/cabaret/__init__.py

@@ -0,0 +1,2 @@
+from cabaret.image import generate_image
+from cabaret.camera import Camera

cabaret-0.0.6/src/cabaret/camera.py

@@ -0,0 +1,24 @@
+from dataclasses import dataclass
+
+
+@dataclass
+class Camera:
+    device_number: int = 0
+    width: int = 1000
+    height: int = 1000
+    max_adu: int = 2**16
+    bin_x: int = 1
+    bin_y: int = 1
+    gain: float = 1.0
+    pitch: float = 12.0
+    plate_scale: float = 0.35
+    well_depth: int = 2**16
+    bias: int = 200
+    read_noise: float = 4.0
+    dark_current: float = 10.0
+    sky_background: float = 10.0
+    quantum_efficiency: float = 1.0
+    collecting_area: float = 10.0
+    temperature: float = -10
+    sensor_name: str = "gaia-camera-simulated"
+    seeing: float = 1.0

cabaret-0.0.6/src/cabaret/image.py

@@ -0,0 +1,150 @@
+import numpy as np
+
+from astropy.coordinates import SkyCoord
+from astropy.wcs import WCS
+
+from datetime import datetime
+
+from cabaret.camera import Camera
+from cabaret.queries import gaia_radecs
+
+
+def moffat_profile(x, y, x0, y0, FWHM, beta=2.5):
+    # https://nbviewer.org/github/ysbach/AO_2017/blob/master/04_Ground_Based_Concept.ipynb#1.2.-Moffat
+    # FWHM =  2 * R * (2**(1/beta) - 1)**0.5
+
+    R = (FWHM / 2) * (1 / (2 ** (1 / beta) - 1) ** 0.5)
+    A = (beta - 1) / (np.pi * R**2)
+
+    r_squared = (x - x0) ** 2 + (y - y0) ** 2
+
+    mp = A * (1 + (r_squared / R**2)) ** (-beta)
+
+    mp_sum = np.sum(mp)
+
+    return mp / mp_sum
+
+
+def generate_star_image(pos, fluxes, FWHM, frame_size):
+    x = np.linspace(0, frame_size[0] - 1, frame_size[0])
+    y = np.linspace(0, frame_size[1] - 1, frame_size[1])
+    xx, yy = np.meshgrid(x, y)
+
+    image = np.zeros(frame_size).T
+    for i, flux in enumerate(fluxes):
+        x0 = pos[0][i]
+        y0 = pos[1][i]
+        star = np.random.poisson(flux) * moffat_profile(xx, yy, x0, y0, FWHM)
+        image += star
+
+    return image
+
+
+def generate_image(
+    ra, dec, exp_time, dateobs=datetime.utcnow(), light=1, camera=Camera, tmass=True
+):
+
+    base = np.ones((camera.height, camera.width)).astype(np.float64)
+    base += camera.bias + np.random.poisson(
+        base * camera.dark_current * exp_time
+    ).astype(np.float64)
+    base += np.random.normal(
+        0, camera.read_noise, (camera.height, camera.width)
+    ).astype(np.float64)
+
+    if light == 1:
+
+        # call gaia
+        center = SkyCoord(ra=ra, dec=dec, unit="deg")
+
+        fovx = (
+            (1 / np.abs(np.cos(center.dec.rad)))
+            * camera.width
+            * camera.plate_scale
+            / 3600
+        )
+        fovy = (
+            np.sqrt(2) * camera.height * camera.plate_scale / 3600
+        )  # to account for poles, maybe should scale instead
+
+        gaias, mags = gaia_radecs(
+            center, (fovx * 1.5, fovy * 1.5), tmass=tmass, dateobs=dateobs
+        )
+
+        wcs = WCS(naxis=2)
+        wcs.wcs.cdelt = [-camera.plate_scale / 3600, -camera.plate_scale / 3600]
+        wcs.wcs.cunit = ["deg", "deg"]
+        wcs.wcs.crpix = [int(camera.width / 2), int(camera.height / 2)]
+        wcs.wcs.crval = [center.ra.deg, center.dec.deg]
+        wcs.wcs.ctype = ["RA---TAN", "DEC--TAN"]
+
+        if len(gaias) > 0:
+            if tmass:
+                # convert mags to fluxes. Reference: https://lweb.cfa.harvard.edu/~dfabricant/huchra/ay145/mags.html
+                Jy = 1.51e7  # [photons sec^-1 m^-2 (dlambda/lambda)^-1]
+                photons = 0.16 * 1600 * Jy  # [photons sec^-1 m^-2] at mag 0
+                fluxes = (
+                    photons
+                    * 10 ** (-0.4 * mags)
+                    * camera.quantum_efficiency
+                    * camera.collecting_area
+                    * exp_time
+                )  # [electrons]
+            else:
+                fluxes = (
+                    fluxes
+                    * camera.quantum_efficiency
+                    * camera.collecting_area
+                    * exp_time
+                )  # [electrons]
+
+            # convert gaia stars to pixel coordinates
+            gaias_pixel = np.array(SkyCoord(gaias, unit="deg").to_pixel(wcs))
+
+            # stars within frame and moffat profile
+            stars = generate_star_image(
+                gaias_pixel,
+                fluxes,
+                camera.seeing / camera.plate_scale,
+                (camera.width, camera.height),
+            ).astype(
+                np.float64
+            )  # * flat
+
+            # make base image with sky background
+            image = base + np.random.poisson(
+                base * camera.sky_background * exp_time
+            ).astype(
+                np.float64
+            )  # * flat
+
+            image += stars
+
+    else:
+        # dark exposure
+        image = base
+
+    # convert to adu and add camera's bias
+    image = image / camera.gain + camera.bias  # [adu]
+
+    # clip to max adu
+    image = np.clip(image, 0, camera.max_adu)
+
+    # make image 16 bit
+    image = image.astype(np.uint16)
+
+    return image
+
+
+if __name__ == "__main__":
+    import matplotlib.pyplot as plt
+
+    # example usage
+    image = generate_image(323.36152, -0.82325, 1)
+
+    fig = plt.figure(figsize=(10, 10))
+
+    med = np.median(image)
+    std = np.std(image)
+    plt.imshow(image, cmap="Greys_r", vmax=3 * std + med, vmin=med - 1 * std)
+    plt.show()

cabaret-0.0.6/src/cabaret/queries.py

@@ -0,0 +1,140 @@
+from typing import Optional, Tuple, Union
+from astropy.units import Quantity
+from astropy.coordinates import SkyCoord
+from datetime import datetime
+import numpy as np
+from astropy import units as u
+
+
+def gaia_radecs(
+    center: Union[Tuple[float, float], SkyCoord],
+    fov: Union[float, Quantity],
+    limit: int = 100000,
+    circular: bool = True,
+    tmass: bool = False,
+    dateobs: Optional[datetime] = None,
+) -> np.ndarray:
+    """
+    Query the Gaia archive to retrieve the RA-DEC coordinates of stars within a given field-of-view (FOV) centered on a given sky position.
+
+    Parameters
+    ----------
+    center : tuple or astropy.coordinates.SkyCoord
+        The sky coordinates of the center of the FOV. If a tuple is given, it should contain the RA and DEC in degrees.
+    fov : float or astropy.units.Quantity
+        The field-of-view of the FOV in degrees. If a float is given, it is assumed to be in degrees.
+    limit : int, optional
+        The maximum number of sources to retrieve from the Gaia archive. By default, it is set to 10000.
+    circular : bool, optional
+        Whether to perform a circular or a rectangular query. By default, it is set to True.
+    tmass : bool, optional
+        Whether to retrieve the 2MASS J magnitudes catelog. By default, it is set to False.
+    dateobs : datetime.datetime, optional
+        The date of the observation. If given, the proper motions of the sources will be taken into account. By default, it is set to None.
+
+    Returns
+    -------
+    np.ndarray
+        An array of shape (n, 2) containing the RA-DEC coordinates of the retrieved sources in degrees.
+
+    Raises
+    ------
+    ImportError
+        If the astroquery package is not installed.
+
+    Examples
+    --------
+    >>> from astropy.coordinates import SkyCoord
+    >>> from twirl import gaia_radecs
+    >>> center = SkyCoord(ra=10.68458, dec=41.26917, unit='deg')
+    >>> fov = 0.1
+    >>> radecs = gaia_radecs(center, fov)
+    """
+    from astroquery.gaia import Gaia
+
+    if isinstance(center, SkyCoord):
+        ra = center.ra.deg
+        dec = center.dec.deg
+    else:
+        ra, dec = center
+
+    if not isinstance(fov, u.Quantity):
+        fov = fov * u.deg
+
+    if fov.ndim == 1:
+        ra_fov, dec_fov = fov.to(u.deg).value
+    else:
+        ra_fov = dec_fov = fov.to(u.deg).value
+
+    radius = np.max([ra_fov, dec_fov]) / 2
+
+    if circular and not tmass:
+        job = Gaia.launch_job(
+            f"""
+            SELECT top {limit} gaia.ra, gaia.dec, gaia.pmra, gaia.pmdec, gaia.phot_rp_mean_flux
+            FROM gaiadr2.gaia_source AS gaia
+            WHERE 1=CONTAINS(
+                POINT('ICRS', {ra}, {dec}), 
+                CIRCLE('ICRS', gaia.ra, gaia.dec, {radius}))
+            ORDER BY gaia.phot_rp_mean_flux DESC
+            """
+        )
+    elif circular and tmass:
+        job = Gaia.launch_job(
+            f"""
+            SELECT top {limit} gaia.ra, gaia.dec, gaia.pmra, gaia.pmdec, gaia.phot_rp_mean_flux, tmass.j_m
+            FROM gaiadr2.gaia_source AS gaia
+            INNER JOIN gaiadr2.tmass_best_neighbour AS tmass_match ON tmass_match.source_id = gaia.source_id
+            INNER JOIN gaiadr1.tmass_original_valid AS tmass ON tmass.tmass_oid = tmass_match.tmass_oid
+            WHERE 1=CONTAINS(
+                POINT('ICRS', {ra}, {dec}), 
+                CIRCLE('ICRS', gaia.ra, gaia.dec, {radius}))
+            ORDER BY tmass.j_m
+            """
+        )
+    elif not circular and tmass:
+        job = Gaia.launch_job(
+            f"""
+            SELECT top {limit} gaia.ra, gaia.dec, gaia.pmra, gaia.pmdec, gaia.phot_rp_mean_flux, tmass.j_m
+            FROM gaiadr2.gaia_source AS gaia
+            INNER JOIN gaiadr2.tmass_best_neighbour AS tmass_match ON tmass_match.source_id = gaia.source_id
+            INNER JOIN gaiadr1.tmass_original_valid AS tmass ON tmass.tmass_oid = tmass_match.tmass_oid
+            WHERE gaia.ra BETWEEN {ra-ra_fov/2} AND {ra+ra_fov/2} AND
+            gaia.dec BETWEEN {dec-dec_fov/2} AND {dec+dec_fov/2}
+            ORDER BY tmass.j_m
+            """
+        )
+    else:
+        job = Gaia.launch_job(
+            f"""
+            SELECT top {limit} gaia.ra, gaia.dec, gaia.pmra, gaia.pmdec, gaia.phot_rp_mean_flux
+            FROM gaiadr2.gaia_source AS gaia
+            WHERE gaia.ra BETWEEN {ra-ra_fov/2} AND {ra+ra_fov/2} AND
+            gaia.dec BETWEEN {dec-dec_fov/2} AND {dec+dec_fov/2}
+            ORDER BY gaia.phot_rp_mean_flux DESC
+            """
+        )
+
+    table = job.get_results()
+
+    # add proper motion to ra and dec
+    if dateobs is not None:
+        # calculate fractional year
+        dateobs = dateobs.year + (dateobs.timetuple().tm_yday - 1) / 365.25  # type: ignore
+
+        years = dateobs - 2015.5  # type: ignore
+        table["ra"] += years * table["pmra"] / 1000 / 3600
+        table["dec"] += years * table["pmdec"] / 1000 / 3600
+
+    if tmass:
+        table.remove_rows(np.isnan(table["j_m"]))
+        return (
+            np.array([table["ra"].value.data, table["dec"].value.data]).T,
+            table["j_m"].value.data,
+        )
+    else:
+        table.remove_rows(np.isnan(table["phot_rp_mean_flux"]))
+        return (
+            np.array([table["ra"].value.data, table["dec"].value.data]).T,
+            table["phot_rp_mean_flux"].value.data,
+        )

cabaret-0.0.6/tests/test_readme.py

@@ -0,0 +1,19 @@
+def test_readme_1():
+    import cabaret
+
+    ra, dec = 12.3323, 30.4343  # in degrees
+    exposure_time = 10  # in seconds
+
+    image = cabaret.generate_image(ra, dec, exposure_time)
+
+
+def test_readme_2():
+    import cabaret
+    from cabaret import Camera
+
+    camera = Camera(read_noise=10, gain=1, width=100, height=100)
+
+    ra, dec = 12.3323, 30.4343  # in degrees
+    exposure_time = 10  # in seconds
+
+    image = cabaret.generate_image(ra, dec, exposure_time, camera=camera)

cabaret-0.0.6/tests/test_simple.py

@@ -0,0 +1,9 @@
+import pytest
+from cabaret import generate_image
+from cabaret import Camera
+
+
+def test_simple():
+    camera = Camera(width=100, height=100)
+    ra, dec = 323.36152, -0.82325
+    image = generate_image(ra, dec, 1, camera=camera)