stdpipe 0.4.0__py3-none-any.whl

stdpipe/utils.py

@@ -0,0 +1,365 @@
+import os
+import re
+import requests
+import dateutil
+import shlex
+
+from tqdm.auto import tqdm
+
+import numpy as np
+from astropy.io import fits
+from astropy.coordinates import SkyCoord
+from astropy import units as u
+from astropy.time import Time
+
+
+def breakpoint():
+    try:
+        from IPython.core.debugger import Tracer
+
+        Tracer()()
+    except:
+        import pdb
+
+        pdb.set_trace()
+
+
+def make_jname(ra, dec):
+    radec = SkyCoord(ra, dec, unit='deg')
+    return "J%s%s" % (
+        radec.ra.to_string(unit=u.hourangle, sep='', precision=2, pad=True),
+        radec.dec.to_string(sep='', precision=1, alwayssign=True, pad=True),
+    )
+
+
+def get_data_path(dataname):
+    """
+    Returns full path to the data file located in the module data/ folder
+    """
+    return os.path.join(os.path.dirname(__file__), 'data', dataname)
+
+
+def download(url, filename=None, overwrite=False, verbose=False):
+    # Simple wrapper around print for logging in verbose mode only
+    log = (verbose if callable(verbose) else print) if verbose else lambda *args, **kwargs: None
+
+    if not overwrite and filename is not None and os.path.exists(filename):
+        log(filename, 'already downloaded')
+        return True
+
+    response = requests.get(url, stream=True, allow_redirects=True)
+    if response.status_code != 200:
+        log('Error %s downloading from %s' % (response.status_code, url))
+        return False
+
+    # FIXME: if server is compressing the data, Content-Length here will be wrong?..
+    size = int(response.headers.get('Content-Length', 0))
+
+    if filename is None:
+        # Some logic to guess filename from headers
+        tmp = re.findall("filename=(.+)", response.headers.get('Content-Disposition', ''))
+        if len(tmp):
+            filename = tmp[1]
+        else:
+            filename = 'download'
+
+        # TODO: check file existence here again?..
+
+    desc = os.path.basename(filename)
+
+    log('Downloading %s from %s...' % (filename, url))
+
+    length = 0
+
+    if verbose:
+        progress = tqdm(desc=desc, total=size, unit='iB', unit_scale=True, unit_divisor=1024)
+    else:
+        progress = None
+
+    with open(filename, 'wb') as file:
+        for chunk in response.iter_content(chunk_size=1024):
+            chunksize = file.write(chunk)
+            if progress is not None:
+                progress.update(chunksize)
+            length += chunksize  # len(chunk)
+
+    if progress is not None:
+        progress.close()
+
+    if size and length < size:
+        log('Downloaded %d bytes, was expecting %d' % (length, size))
+        return False
+    else:
+        log('Successfully downloaded %d bytes' % length)
+        return True
+
+
+def get_obs_time(header=None, filename=None, string=None, get_datetime=False, verbose=False):
+    """Extract date and time of observations from a FITS header or string.
+
+    Tries the following FITS keywords in order: ``DATE-OBS``, ``DATEOBS``,
+    ``DATE``, ``TIME-OBS``, ``TIMEOBS``, ``UT``, ``MJD``, ``JD``.
+
+    Parameters
+    ----------
+    header : astropy.io.fits.Header, optional
+        FITS header containing observation time keywords.
+    filename : str, optional
+        Path to a FITS file; its header is loaded if ``header`` is not provided.
+    string : str, optional
+        Time string to parse directly instead of using a FITS header.
+    get_datetime : bool, optional
+        If True, return a :class:`datetime.datetime` instead of
+        :class:`astropy.time.Time`.
+    verbose : bool or callable, optional
+        Whether to show verbose messages. May be boolean or a ``print``-like callable.
+
+    Returns
+    -------
+    astropy.time.Time or datetime.datetime or None
+        Parsed observation time, or None if parsing fails.
+    """
+
+    # Simple wrapper around print for logging in verbose mode only
+    log = (verbose if callable(verbose) else print) if verbose else lambda *args, **kwargs: None
+
+    # Simple wrapper to display parsed value and convert it as necessary
+    def convert_time(time):
+        if isinstance(time, float):
+            # Try to parse floating-point value as MJD or JD, depending on the value
+            if time > 0 and time < 100000:
+                log('Assuming it is MJD')
+                time = Time(time, format='mjd')
+            elif time > 2400000 and time < 2500000:
+                log('Assuming it is JD')
+                time = Time(time, format='jd')
+            else:
+                # Then it is probably an Unix time?..
+                log('Assuming it is Unix time')
+                time = Time(time, format='unix')
+
+        else:
+            if isinstance(time, str):
+                # Special case where some telescope used '-' for time separation instead of ISO ':'
+                m = re.fullmatch(
+                    r"(\d\d\d\d-\d\d-\d\dT\d\d)-(\d\d)-(\d\d(?:\.\d{1,6})?)", time.strip()
+                )
+                if m:
+                    time = ":".join(m.groups())
+            time = Time(time)
+
+        log('Time parsed as:', time.iso)
+        if get_datetime:
+            return time.datetime
+        else:
+            return time
+
+    if string:
+        log('Parsing user-provided time string:', string)
+        try:
+            return convert_time(dateutil.parser.parse(string))
+        except dateutil.parser.ParserError as err:
+            log('Could not parse user-provided string:', err)
+            return None
+
+    if header is None:
+        log('Loading FITS header from', filename)
+        header = fits.getheader(filename)
+
+    for dkey in ['DATE-OBS', 'DATEOBS', 'DATE', 'TIME-OBS', 'TIMEOBS', 'UT', 'MJD', 'JD']:
+        if dkey in header:
+            log('Found ' + dkey + ':', header[dkey])
+            # First try to parse standard ISO time
+            try:
+                return convert_time(header[dkey])
+            except:
+                log('Could not parse ' + dkey + ' using Astropy parser')
+
+            for tkey in ['TIME-OBS', 'TIMEOBS', 'UT']:
+                if tkey in header:
+                    log('Found ' + tkey + ':', header[tkey])
+                    try:
+                        return convert_time(
+                            dateutil.parser.parse(header[dkey] + ' ' + header[tkey])
+                        )
+                    except dateutil.parser.ParserError as err:
+                        log('Could not parse ' + dkey + ' + ' + tkey + ':', err)
+
+    log('Unsupported FITS header time format')
+
+    return None
+
+
+def table_get(table, colname, default=0):
+    """
+    Simple wrapper to get table column, or default value if it is not present
+    """
+
+    if colname in table.colnames:
+        return table[colname]
+    elif default is None:
+        return None
+    elif hasattr(default, '__len__'):
+        # default value is array, return it
+        return default
+    else:
+        # Broadcast scalar to proper length
+        return default * np.ones(len(table), dtype=int)
+
+
+def format_astromatic_opts(opts):
+    """
+    Auxiliary function to format dictionary of options into Astromatic compatible command-line string.
+    Booleans are converted to Y/N, arrays to comma separated lists, strings are quoted when necessary
+    """
+    result = []
+
+    for key in opts.keys():
+        if opts[key] is None:
+            pass
+        elif type(opts[key]) == bool:
+            result.append('-%s %s' % (key, 'Y' if opts[key] else 'N'))
+        else:
+            value = opts[key]
+
+            if type(value) == str:
+                value = shlex.quote(value)
+            elif hasattr(value, '__len__'):
+                value = ','.join([str(_) for _ in value])
+
+            result.append('-%s %s' % (key, value))
+
+    result = ' '.join(result)
+
+    return result
+
+
+def format_long_opts(opts):
+    """
+    Auxiliary function to format dictionary of options into a command-line string.
+    Boolean options are added when True, strings are quoted when necessary
+    """
+    result = []
+
+    for key in opts.keys():
+        if opts[key] is None:
+            pass
+        elif type(opts[key]) == bool:
+            if opts[key]:
+                result.append('--%s' % key)
+        else:
+            value = opts[key]
+
+            if type(value) == str:
+                value = shlex.quote(value)
+
+            result.append('--%s %s' % (key, value))
+
+    result = ' '.join(result)
+
+    return result
+
+
+# Parsing of DATASEC-like keywords
+def parse_det(string):
+    """
+    Parse DATASEC-like keyword
+    """
+
+    x0, x1, y0, y1 = [int(_) - 1 for _ in sum([_.split(':') for _ in string[1:-1].split(',')], [])]
+
+    return x0, x1, y0, y1
+
+
+# Cropping of overscans if any
+def crop_overscans(image, header, subtract_bias=True, verbose=False):
+    """
+    Crop overscans from input image based on its header keywords.
+    Also, subtract the 'bias' value estimated from overscan.
+    """
+
+    # Simple wrapper around print for logging in verbose mode only
+    log = (verbose if callable(verbose) else print) if verbose else lambda *args, **kwargs: None
+
+    if header is not None:
+        header = header.copy()
+
+    bias = 0
+
+    for kw in ['BIASSEC']:
+        if kw in header:
+            x1, x2, y1, y2 = parse_det(header.get(kw))
+            biasimg = image[y1 : y2 + 1, x1 : x2 + 1]
+
+            bias = np.mean(biasimg)
+            log('Estimated bias level using %s: %s = %.2f' % (kw, header.get(kw), bias))
+
+    for kw in ['TRIMSEC', 'DATASEC']:
+        if kw in header:
+            x1, x2, y1, y2 = parse_det(header.get(kw))
+
+            if header is not None and header.get('CRPIX1') is not None:
+                header['CRPIX1'] -= x1
+                header['CRPIX2'] -= y1
+
+            image = image[y1 : y2 + 1, x1 : x2 + 1]
+            log('Cropped image using %s: %s' % (kw, header.get(kw)))
+
+            break
+
+    for kw in ['BIASSEC', 'TRIMSEC', 'DATASEC']:
+        if kw in header:
+            header[kw + '0'] = header.pop(kw)
+
+    image -= bias
+
+    return image, header
+
+
+# Simple 2D rebinning
+def rebin_image(image, nx=1, ny=None):
+    """
+    Simple rebinning / downscaling the image by an integer factor.
+    Pixel values are averaged, not co-added.
+    """
+    if ny is None:
+        ny = nx
+    shape = (image.shape[0] // ny, ny, image.shape[1] // nx, nx)
+    return image.reshape(shape).mean(-1).mean(1)
+
+
+# Simple writing of some data to file
+def file_write(filename, contents=None, append=False):
+    """
+    Simple utility for writing some contents into file.
+    """
+
+    with open(filename, 'a' if append else 'w') as f:
+        if contents is not None:
+            f.write(contents)
+
+
+# Simple reading of data from file
+def file_read(filename, contents=None):
+    """
+    Simple utility for reading some contents from file.
+    """
+
+    if os.path.exists(filename):
+        with open(filename, 'r') as f:
+            return f.read()
+
+    return None
+
+
+# Writing of FITS-compressed files
+def fits_write(filename, image, header=None, compress=False):
+    """
+    Store image with or without header to FITS file, with or without compression
+    """
+    if compress:
+        hdu = fits.CompImageHDU(image, header)
+    else:
+        hdu = fits.PrimaryHDU(image, header)
+
+    hdu.writeto(filename, overwrite=True)

stdpipe-0.4.0.dist-info/METADATA

@@ -0,0 +1,171 @@
+Metadata-Version: 2.4
+Name: stdpipe
+Version: 0.4.0
+Summary: Simple Transient Detection Pipeline
+Author-email: Sergey Karpov <karpov.sv@gmail.com>
+Maintainer-email: Sergey Karpov <karpov.sv@gmail.com>
+License: MIT License
+        
+        Copyright (c) 2022 Sergey Karpov
+        
+        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.
+        
+Project-URL: Homepage, https://github.com/karpov-sv/stdpipe
+Project-URL: Documentation, https://stdpipe.readthedocs.io/
+Project-URL: Repository, https://github.com/karpov-sv/stdpipe
+Project-URL: Bug Tracker, https://github.com/karpov-sv/stdpipe/issues
+Project-URL: Changelog, https://github.com/karpov-sv/stdpipe/commits/master
+Keywords: astronomy,astrophysics,transients,photometry,astrometry,image-processing,pipeline
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Scientific/Engineering :: Astronomy
+Classifier: Topic :: Scientific/Engineering :: Image Processing
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE.md
+Requires-Dist: numpy
+Requires-Dist: scipy
+Requires-Dist: astropy>=4.1
+Requires-Dist: matplotlib
+Requires-Dist: astroquery>0.4.1
+Requires-Dist: sep-x
+Requires-Dist: astroscrappy
+Requires-Dist: photutils>=2.2
+Requires-Dist: scikit-image>=0.22.0
+Requires-Dist: statsmodels
+Requires-Dist: tqdm
+Requires-Dist: regions
+Requires-Dist: python-dateutil
+Requires-Dist: requests
+Requires-Dist: pyfftw
+Requires-Dist: scikit-learn
+Provides-Extra: dev
+Requires-Dist: pytest>=6.0; extra == "dev"
+Requires-Dist: pytest-cov>=2.10; extra == "dev"
+Requires-Dist: pytest-xdist>=2.0; extra == "dev"
+Requires-Dist: pytest-mock>=3.0; extra == "dev"
+Requires-Dist: pytest-timeout>=2.0; extra == "dev"
+Requires-Dist: pytest-benchmark>=3.4; extra == "dev"
+Requires-Dist: hypothesis>=6.0; extra == "dev"
+Provides-Extra: docs
+Requires-Dist: sphinx>=4.0; extra == "docs"
+Requires-Dist: sphinx-rtd-theme; extra == "docs"
+Requires-Dist: sphinx-math-dollar; extra == "docs"
+Requires-Dist: numpydoc; extra == "docs"
+Requires-Dist: myst-parser; extra == "docs"
+Requires-Dist: sphinxcontrib-apidoc; extra == "docs"
+Requires-Dist: sphinx-prompt; extra == "docs"
+Provides-Extra: adaptive
+Requires-Dist: powerbin; extra == "adaptive"
+Provides-Extra: ml
+Requires-Dist: tensorflow<2.20,>=2.10; extra == "ml"
+Provides-Extra: all
+Requires-Dist: stdpipe[adaptive,dev,docs,ml]; extra == "all"
+Dynamic: license-file
+
+# STDPipe - Simple Transient Detection Pipeline
+*AKA: random codes noone else will ever use*
+
+*STDPipe* is a set of Python routines for astrometry, photometry and transient detection related tasks, intended for quick and easy implementation of custom pipelines, as well as for interactive data analysis.
+
+### Design principles
+ - implemented as a library of routines covering most common tasks
+ - operates on standard Python objects: NumPy arrays for images, Astropy Tables for catalogs and object lists, etc
+ - does not try to re-implement the things already implemented in other Python packages
+ - conveniently wraps external codes that do not have their own Python interfaces (*SExtractor*, *SCAMP*, *PSFEx*, *HOTPANTS*, *Astrometry.Net*, ...)
+     - wrapping is transparent: all data passed from Python, all options customizable from Python, all (or most of) outputs available back
+     - everything operates on temporary files, nothing is kept after the run unless explicitly asked for
+
+### Features
+ - ~~pre-processing~~ - should be handled before in an instrument-specific way
+     - bias/dark subtraction, flatfielding, masking
+ - object detection and photometry
+     - SExtractor, SEP, or photutils (pure Python) for detection
+     - aperture, optimal extraction (Naylor 1998), and PSF fitting photometry
+     - grouped fitting for crowded fields
+ - astrometric calibration
+     - Astrometry.Net for blind WCS solving
+     - quad-hash pattern matching for refinement (pure Python, no external deps, default method)
+     - SCAMP or Astropy-based code for refinement (alternative)
+ - photometric calibration
+     - Vizier catalogues, passband conversion (PS1 to Johnson, Gaia to Johnson, ...)
+     - spatial polynomial + color term + intrinsic scatter
+ - image reprojection and stacking
+     - Lanczos interpolation with automatic oversampling and flux conservation (pure Python, default)
+     - SWarp wrapper (alternative)
+ - image subtraction
+     - HiPS templates
+     - PanSTARRS DR1 or Legacy Survey templates
+     - HOTPANTS + custom noise model
+     - ZOGY
+ - transient detection and classification
+     - noise-weighted detection, cutout adjustment, ...
+     - feature-based real/bogus classification (no TensorFlow required)
+     - CNN-based real/bogus classification (optional, requires TensorFlow)
+ - auxiliary functions
+     - PSF estimation, simulated stars, FITS header utilities, plotting, ...
+ - light curve creation (soon)
+     - spatial clustering, color regression, variability analysis, ...
+
+# Installation
+
+*STDpipe* is available at https://github.com/karpov-sv/stdpipe and is mirrored at https://gitlab.in2p3.fr/icare/stdpipe
+
+The package is in constant development, so to keep track of the changes the suggested way of installing it is by cloning the repository
+```
+git clone https://github.com/karpov-sv/stdpipe.git
+```
+and then installing from it in development (or "editable") mode by running the command
+```
+cd stdpipe
+python3 -m pip install -e .
+```
+This way you may update the repository or apply local patches, and it will immediately be reflected in the installed package.
+
+Apart of Python requirements that will be installed automatically, *STDPipe* also (optionally) makes use of the following external software:
+ - [SExtractor](https://github.com/astromatic/sextractor)
+ - [SCAMP](https://github.com/astromatic/scamp)
+ - [PSFEx](https://github.com/astromatic/psfex)
+ - [SWarp](https://github.com/astromatic/swarp)
+ - [HOTPANTS](https://github.com/acbecker/hotpants)
+ - [Astrometry.Net](https://github.com/dstndstn/astrometry.net)
+
+Most of them may be installed from your package manager. E.g. on Debian or Ubuntu systems it may look like that:
+```
+sudo apt install sextractor scamp psfex swarp
+```
+or, on Miniconda/Anaconda, like that:
+```
+conda install -c conda-forge astromatic-source-extractor astromatic-scamp astromatic-psfex astromatic-swarp
+```
+
+You may also check more detailed installation instructions [here](https://stdpipe.readthedocs.io/en/latest/installation.html).
+
+# Usage
+
+Please consult the [documentation for *STDPipe*](https://stdpipe.readthedocs.io/) for the basic usage patterns and description of its API. You may check the examples inside [notebooks/](notebooks/) folder, especially the [tutorial](notebooks/stdpipe_tutorial.ipynb) that demonstrates basic steps of a typical image processing.

stdpipe-0.4.0.dist-info/RECORD

@@ -0,0 +1,37 @@
+stdpipe/__init__.py,sha256=6ZJ6LfuhuURE18kIKKOkR6El1Re1GBaGT3OXIKVmL34,289
+stdpipe/artefacts.py,sha256=ON_cFLluXY58H-YsoDORIzByjRGH3La8yVGVwUUQjyg,12934
+stdpipe/astrometry.py,sha256=ieaPysfyHQSCiYV9FGjdmt13ErdRNC09K24l4KcYMdw,68386
+stdpipe/astrometry_quad.py,sha256=vyrd-6E9knTquwW_kvPblVmuyjlyvB1lkMkCtEDx2tM,62011
+stdpipe/astrometry_wcs.py,sha256=mQllKUG_x2qYeeHZPvKwxHVDJE2M9k3uAzyQQ7Fndps,40720
+stdpipe/catalogs.py,sha256=mHL-ZW8ocqKdlfHqszj-u8CYK7HcJa9zYcwJYfxGNZ0,33628
+stdpipe/cutouts.py,sha256=otYUsUDsEgtGc4EYZz9we4sCbofOETirxQghHCX7y6I,17717
+stdpipe/db.py,sha256=hosPbMp7ugAw8WuQIr4sBITb-tqL8neQ-dnhkhbx7hU,4724
+stdpipe/fringe_removal.py,sha256=TFbX0OY4xwPGIf3rfcWkV5jpvW0OLVgBzpo326WMKpg,39955
+stdpipe/lcs.py,sha256=-oNlk6GjfRcFYCkAX87b_gijBLKb4mACJ6ZOEhPamL0,16272
+stdpipe/photometry.py,sha256=a6L6pTVx0lBt2LOS3vetlKitSwFqCPkOZOTY3i4yKho,83110
+stdpipe/photometry_background.py,sha256=7KsM6xSH2ZF-V6V2Y5vK20Kci2SmCv-p25pdxPz5v0k,36502
+stdpipe/photometry_iraf.py,sha256=DU0XQR5JkpGSck1OeuaTr5ljR4fHpspDo3WAewtdyR8,31834
+stdpipe/photometry_measure.py,sha256=sGaq2sqw7eKEm2fnCJX88gjF7Pe5tdtns8CtnetO9HA,84974
+stdpipe/photometry_model.py,sha256=usBVJtqSX8dpeOVf4eNFbkrv41U7BhiXYP3uZY5zHto,31791
+stdpipe/photometry_psf.py,sha256=sQTHl-810CogKLhvN7eThiVE_QIG9V3-YPsmmmJP9fU,45975
+stdpipe/photometry_quality.py,sha256=8Qr706ysGDGm66tKzEb2JJdFMD0OWJEzjzJkG2BoXE0,7023
+stdpipe/pipeline.py,sha256=bM4v1xtj7kKjeb_czn1Q-5qxYzV4onFLqisaA8Gw1VY,43915
+stdpipe/plots.py,sha256=J0D6_041mpg3UrKZnHyP8hBSOrqtiNdL0TxvP37FLUg,51250
+stdpipe/psf.py,sha256=ml6IF3cv78nT-9qNjYt_8Q5j_EgajAFqn1dUdVPgYW8,56236
+stdpipe/realbogus.py,sha256=LWP1mDXPxmPEa9sMK88DVNxKW-qRB1u0sgFK3xsvbdo,31583
+stdpipe/realbogus_features.py,sha256=bbMQ9WCb4gxjelTmZMn5T2G5ALJpcrpZir2ihtbzqoc,53824
+stdpipe/reproject.py,sha256=cU7HmpBQfF85_9Qm7hq63BBb4amnefU_YsQqmffip5A,31913
+stdpipe/resolve.py,sha256=IQr_4zn89l54s88iNjojI0lP9zsKfrrWkhdPCnc7GF8,8990
+stdpipe/sfft.py,sha256=x_QV-oknIGG0QAdk4VeeESahOXUXoRvjv0JinpZq0IU,41082
+stdpipe/simulation.py,sha256=dplowLWkrHCxTjZrM4WYEEdTbf4g79mZTgn2mHKnPVU,72354
+stdpipe/smoothing.py,sha256=lVLjWiKVX07bKsnLIO2LAQ-7MoPKlxi5GpcLa1YMKPc,19130
+stdpipe/subtraction.py,sha256=pSd_hjvNJMXp-qtqBigHnrHvFtqze7hzKw8UVMLglm8,49582
+stdpipe/templates.py,sha256=oX2rXuT7uHN_KYzSvjiAM6iN-gArUh2W3YxIJX0r-WM,31008
+stdpipe/utils.py,sha256=9ZSu1xjqs9VgIdNolrI39Ls84DUf6MXprsHCTT4ynDw,11131
+stdpipe/data/legacysurvey_bricks.fits.gz,sha256=Rq6DSn5g0ZXJiGKKDUyx9C82cb_KCSq2aNMcKjGwEJ8,4254781
+stdpipe/data/ps1skycells.txt,sha256=lZkykMWXRxuNBMOI3kwjAQYFem7ddioG2LOIx-5Y0Ms,8972943
+stdpipe-0.4.0.dist-info/licenses/LICENSE.md,sha256=sTpMtA36_ilynqyuY9sLiCp4pN6xNfIyQrDID5wjjj4,1070
+stdpipe-0.4.0.dist-info/METADATA,sha256=9zNh8yzkK0WyBIj1EFzywhzxNuj5RCoqTZ7Npe2cKd0,8350
+stdpipe-0.4.0.dist-info/WHEEL,sha256=K260EYznzXsJYBQGqmI8VTxEdiZYNvDZwW9cBh9-_MA,91
+stdpipe-0.4.0.dist-info/top_level.txt,sha256=f3r9hh1IEMpDvQFYBm00aH73Fp9QPcUOYQpQBeyxaas,8
+stdpipe-0.4.0.dist-info/RECORD,,

stdpipe-0.4.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (83.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

stdpipe-0.4.0.dist-info/licenses/LICENSE.md

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2022 Sergey Karpov
+
+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.

stdpipe-0.4.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+stdpipe