drizzle 1.15.0__cp310-cp310-win_amd64.whl

drizzle/util.py

@@ -0,0 +1,256 @@
+import numpy as np
+
+
+def find_keyword_extn(fimg, keyword, value=None):
+    """
+    This function will return the index of the extension in a multi-extension
+    FITS file which contains the desired keyword with the given value.
+
+    Parameters
+    ----------
+
+    fimg : hdulist
+        A list of header data units
+
+    keyword : str
+        The keyword to search for
+
+    value : str or number, optional
+        If set, the value the keyword must have to match
+
+    Returns
+    -------
+
+    The index of the extension
+    """
+
+    i = 0
+    extnum = -1
+    # Search through all the extensions in the FITS object
+    for chip in fimg:
+        hdr = chip.header
+        # Check to make sure the extension has the given keyword
+        if keyword in hdr:
+            if value is not None:
+                # If it does, then does the value match the desired value
+                # MUST use 'str.strip' to match against any input string!
+                if hdr[keyword].strip() == value:
+                    extnum = i
+                    break
+            else:
+                extnum = i
+                break
+        i += 1
+    # Return the index of the extension which contained the
+    # desired EXTNAME value.
+    return extnum
+
+
+def get_extn(fimg, extn=''):
+    """
+    Returns the FITS extension corresponding to extension specified in
+    filename. Defaults to returning the first extension with data or the
+    primary extension, if none have data.
+
+    Parameters
+    ----------
+
+    fimg : hdulist
+        A list of header data units
+
+    extn : str
+        The extension name and version to match
+
+    Returns
+    -------
+
+    The matching header data unit
+    """
+
+    if extn:
+        try:
+            _extn = parse_extn(extn)
+            if _extn[0]:
+                _e = fimg.index_of(_extn)
+            else:
+                _e = _extn[1]
+
+        except KeyError:
+            _e = None
+
+        if _e is None:
+            _extn = None
+        else:
+            _extn = fimg[_e]
+
+    else:
+        # If no extension is provided, search for first extension
+        # in FITS file with data associated with it.
+
+        # Set up default to point to PRIMARY extension.
+        _extn = fimg[0]
+        # then look for first extension with data.
+        for _e in fimg:
+            if _e.data is not None:
+                _extn = _e
+                break
+
+    return _extn
+
+
+def get_keyword(fimg, keyword, default=None):
+    """
+    Return a keyword value from the header of an image,
+    or the default if the keyword is not found.
+
+    Parameters
+    ----------
+
+    fimg : hdulist
+        A list of header data units
+
+    keyword : hdulist
+        The keyword value to search for
+
+    default : str or number, optional
+        The default value if not found
+
+    Returns
+    -------
+
+    The value if found or default if not
+    """
+
+    value = None
+    if keyword:
+        _nextn = find_keyword_extn(fimg, keyword)
+        try:
+            value = fimg[_nextn].header[keyword]
+        except KeyError:
+            value = None
+
+    if value is None and default is not None:
+        value = default
+
+    return value
+
+
+def is_blank(value):
+    """
+    Determines whether or not a value is considered 'blank'.
+
+    Parameters
+    ----------
+
+    value : str
+        The value to check
+
+    Returns
+    -------
+
+    True or False
+    """
+    return value.strip() == ""
+
+
+def parse_extn(extn=''):
+    """
+    Parse a string representing a qualified fits extension name as in the
+    output of parse_filename and return a tuple (str(extname), int(extver)),
+    which can be passed to pyfits functions using the 'ext' kw.
+    Default return is the first extension in a fits file.
+
+    Examples
+    --------
+        >>> parse_extn('sci,2')
+        ('sci', 2)
+        >>> parse_extn('2')
+        ('', 2)
+        >>> parse_extn('sci')
+        ('sci', 1)
+
+    Parameters
+    ----------
+    extn : str
+        The extension name
+
+    Returns
+    -------
+    A tuple of the extension name and value
+    """
+    if not extn:
+        return ('', 0)
+
+    try:
+        lext = extn.split(',')
+    except Exception:
+        return ('', 1)
+
+    if len(lext) == 1 and lext[0].isdigit():
+        return ("", int(lext[0]))
+    elif len(lext) == 2:
+        return (lext[0], int(lext[1]))
+    else:
+        return (lext[0], 1)
+
+
+def parse_filename(filename):
+    """
+    Parse out filename from any specified extensions.
+    Returns rootname and string version of extension name.
+
+    Parameters
+    ----------
+
+    filename : str
+        The filename to be parsed
+
+    Returns
+    -------
+
+    A tuple with the filename root and extension
+    """
+    # Parse out any extension specified in filename
+    _indx = filename.find('[')
+    if _indx > 0:
+        # Read extension name provided
+        _fname = filename[:_indx]
+        _extn = filename[_indx + 1:-1]
+    else:
+        _fname = filename
+        _extn = ''
+
+    return _fname, _extn
+
+
+def set_pscale(the_wcs):
+    """
+    Calculates the plate scale from cdelt and the pc  matrix and adds
+    it to the WCS. Plate scale is not part of the WCS standard, but is
+    required by the drizzle code
+
+    Parameters
+    ----------
+
+    the_wcs : wcs
+        A WCS object
+    """
+    try:
+        cdelt = the_wcs.wcs.get_cdelt()
+        pc = the_wcs.wcs.get_pc()
+
+    except Exception:
+        try:
+            # for non-celestial axes, get_cdelt doesnt work
+            cdelt = the_wcs.wcs.cd * the_wcs.wcs.cdelt
+        except AttributeError:
+            cdelt = the_wcs.wcs.cdelt
+
+        try:
+            pc = the_wcs.wcs.pc
+        except AttributeError:
+            pc = 1
+
+    pccd = np.array(cdelt * pc)
+    scales = np.sqrt((pccd ** 2).sum(axis=0, dtype=float))
+    the_wcs.pscale = scales[0]

drizzle-1.15.0.dist-info/LICENSE.rst

@@ -0,0 +1,31 @@
+Copyright (C) 2011,2014 Association of Universities for Research in
+Astronomy (AURA)
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions
+are met:
+
+    1. Redistributions of source code must retain the above
+      copyright notice, this list of conditions and the following
+      disclaimer.
+
+    2. Redistributions in binary form must reproduce the above
+      copyright notice, this list of conditions and the following
+      disclaimer in the documentation and/or other materials
+      provided with the distribution.
+
+    3. The name of AURA and its representatives may not be used to
+      endorse or promote products derived from this software without
+      specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY AURA ``AS IS'' AND ANY EXPRESS OR
+IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ARE DISCLAIMED. IN NO EVENT SHALL AURA BE LIABLE FOR ANY DIRECT,
+INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
+OF THE POSSIBILITY OF SUCH DAMAGE.

drizzle-1.15.0.dist-info/METADATA

@@ -0,0 +1,364 @@
+Metadata-Version: 2.1
+Name: drizzle
+Version: 1.15.0
+Summary: A package for combining dithered images into a single image
+Author-email: STScI <help@stsci.edu>
+License: Copyright (C) 2011,2014 Association of Universities for Research in
+        Astronomy (AURA)
+        
+        Redistribution and use in source and binary forms, with or without
+        modification, are permitted provided that the following conditions
+        are met:
+        
+            1. Redistributions of source code must retain the above
+              copyright notice, this list of conditions and the following
+              disclaimer.
+        
+            2. Redistributions in binary form must reproduce the above
+              copyright notice, this list of conditions and the following
+              disclaimer in the documentation and/or other materials
+              provided with the distribution.
+        
+            3. The name of AURA and its representatives may not be used to
+              endorse or promote products derived from this software without
+              specific prior written permission.
+        
+        THIS SOFTWARE IS PROVIDED BY AURA ``AS IS'' AND ANY EXPRESS OR
+        IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+        WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+        ARE DISCLAIMED. IN NO EVENT SHALL AURA BE LIABLE FOR ANY DIRECT,
+        INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+        (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+        SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+        HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+        STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+        ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
+        OF THE POSSIBILITY OF SUCH DAMAGE.
+        
+Project-URL: Homepage, https://github.com/spacetelescope/drizzle
+Project-URL: Bug Tracker, https://github.com/spacetelescope/drizzle/issues
+Project-URL: Documentation, http://spacetelescope.github.io/drizzle/
+Project-URL: Source Code, https://github.com/spacetelescope/drizzle
+Requires-Python: >=3.9
+Description-Content-Type: text/x-rst
+License-File: LICENSE.rst
+Requires-Dist: numpy
+Requires-Dist: astropy
+Provides-Extra: docs
+Requires-Dist: sphinx ; extra == 'docs'
+Requires-Dist: sphinx-automodapi ; extra == 'docs'
+Requires-Dist: sphinx-rtd-theme ; extra == 'docs'
+Requires-Dist: matplotlib ; extra == 'docs'
+Requires-Dist: tomli ; (python_version < "3.11") and extra == 'docs'
+Provides-Extra: test
+Requires-Dist: pytest ; extra == 'test'
+
+drizzle Documentation
+=====================
+
+.. image:: http://img.shields.io/badge/powered%20by-AstroPy-orange.svg?style=flat
+    :target: http://www.astropy.org
+    :alt: Powered by Astropy Badge
+
+.. image:: https://codecov.io/github/spacetelescope/drizzle/branch/main/graphs/badge.svg
+    :target: https://codecov.io/gh/spacetelescope/drizzle
+    :alt: Drizzle's Coverage Status
+
+.. image:: https://github.com/spacetelescope/drizzle/workflows/CI/badge.svg
+    :target: https://github.com/spacetelescope/drizzle/actions
+    :alt: CI Status
+
+.. image:: https://readthedocs.org/projects/spacetelescope-drizzle/badge/?version=latest
+    :target: https://spacetelescope-drizzle.readthedocs.io/en/latest/?badge=latest
+    :alt: Documentation Status
+
+.. image:: https://img.shields.io/pypi/v/drizzle.svg
+    :target: https://pypi.org/project/drizzle
+    :alt: PyPI Status
+
+The ``drizzle`` library is a Python package for combining dithered images into a
+single image. This library is derived from code used in DrizzlePac. Like
+DrizzlePac, most of the code is implemented in the C language. The biggest
+change from DrizzlePac is that this code passes an array that maps the input to
+output image into the C code, while the DrizzlePac code computes the mapping by
+using a Python callback. Switching to using an array allowed the code to be
+greatly simplified.
+
+The DrizzlePac code is currently used in the Space Telescope processing
+pipelines. This library is forward looking in that it can be used with
+the new GWCS code.
+
+Requirements
+------------
+
+- Python 3.9 or later
+
+- Numpy
+
+- Astropy
+
+The Drizzle Algorithm
+---------------------
+
+This section has been extracted from Chapter 2 of
+`The DrizzlePac Handbook <http://www.stsci.edu/hst/HST_overview/drizzlepac/documents/handbooks/drizzlepac.pdf>`_ [Driz2012]_
+
+There are a family of linear reconstruction techniques that, at two opposite
+extremes, are represented by the interlacing and shift-and-add techniques, with
+the Drizzle algorithm representing a continuum between these two extremes.
+
+If the dithers are particularly well-placed, one can simply interlace the pixels
+from the images onto a finer grid. In the interlacing method, pixels from the
+independent input images are placed in alternate pixels on the output image
+according to the alignment of the pixel centers in the original images. However,
+due to occasional small positioning errors by the telescope, and non-uniform
+shifts in pixel space across the detector caused by geometric distortion of the
+optics, true interlacing of images is generally not feasible.
+
+Another standard simple linear technique for combining shifted images,
+descriptively named “shift-and-add”, has been used for many years to combine
+dithered infrared data onto finer grids. Each input pixel is block-replicated
+onto a finer subsampled grid, shifted into place, and added to the output image.
+Shift-and-add has the advantage of being able to easily handle arbitrary dither
+positions. However, it convolves the image yet again with the original pixel,
+thus adding to the blurring of the image and to the correlation of noise in the
+image. Furthermore, it is difficult to use shift-and-add in the presence of
+missing data (e.g., from cosmic rays) and geometric distortion.
+
+In response to the limitations of the two techniques described above, an
+improved method known formally as variable-pixel linear reconstruction, and more
+commonly referred to as Drizzle, was developed by Andy Fruchter and Richard
+Hook, initially for the purposes of combining dithered images of the Hubble Deep
+Field North (HDF-N). This algorithm can be thought of as a continuous set of
+linear functions that vary smoothly between the optimum linear combination
+technique (interlacing) and shift-and-add. This often allows an improvement in
+resolution and a reduction in correlated noise, compared with images produced by
+only using shift-and-add.
+
+The degree to which the algorithm departs from interlacing and moves towards
+shift-and-add depends upon how well the PSF is subsampled by the shifts in the
+input images. In practice, the behavior of the Drizzle algorithm is controlled
+through the use of a parameter called pixfrac, which can be set to values
+ranging from 0 to 1, that represents the amount by which input pixels are shrunk
+before being mapped onto the output image plane.
+
+A key to understanding the use of pixfrac is to realize that a CCD image can be
+thought of as the true image convolved first by the optics, then by the pixel
+response function (ideally a square the size of a pixel), and then sampled by a
+delta-function at the center of each pixel. A CCD image is thus a set of point
+samples of a continuous two-dimensional function. Hence the natural value of
+pixfrac is 0, which corresponds to pure interlacing. Setting pixfrac to values
+greater than 0 causes additional broadening of the output PSF by convolving the
+original PSF with pixels of non-zero size. Thus, setting pixfrac to its maximum
+value of 1 is equivalent to shift-and-add, the other extreme of linear
+combination, in which the output image PSF has been smeared by a convolution
+with the full size of the original input pixels.
+
+The Drizzle algorithm is conceptually straightforward. Pixels in the original
+input images are mapped into pixels in the subsampled output image, taking into
+account shifts and rotations between images and the optical distortion of the
+camera. However, in order to avoid convolving the image with the large pixel
+“footprint” of the camera, Drizzle allows the user to shrink the pixel before it
+is averaged into the output image through the pixfrac parameter.
+
+The flux value of each input pixel is divided up into the output pixels with
+weights proportional to the area of overlap between the “drop” and each output
+pixel. If the drop size is too small, not all output pixels have data added to
+them from each of the input images. One should therefore choose a drop size that
+is small enough to avoid convolving the image with too large an input pixel
+footprint, yet sufficiently large to ensure that there is not too much variation
+in the number of input pixels contributing to each output pixel.
+
+When images are combined using Drizzle, a weight map can be specified for each
+input image. The weight image contains information about bad pixels in the image
+(in that bad pixels result in lower weight values). When the final output
+science image is generated, an output weight map which combines information from
+all the input weight images, is also saved.
+
+Drizzle has a number of advantages over standard linear reconstruction methods.
+Since the pixel area can be scaled by the Jacobian of the geometric distortion,
+it is preserved for surface and absolute photometry. Therefore, the flux in the
+drizzled image, that was corrected for geometric distortion, can be measured
+with an aperture size that's not dependent of its position on the image. Since
+the Drizzle code anticipates that a given output pixel might not receive any
+information from an input pixel, missing data does not cause a substantial
+problem as long as the observer has taken enough dither samples to fill in the
+missing information.
+
+The blot methods perform the inverse operation of drizzle. That is, blotting
+performs the inverse mapping to transform the dithered median image back into
+the coordinate system of the original input image. Blotting is primarily used
+for identifying cosmic rays in the original image. Like the original drizzle
+task, blot requires the user to provide the world coordinate system (WCS)
+transformations as inputs.
+
+.. [Driz2012] Gonzaga, S., Hack, W., Fruchter, A., Mack, J., eds. 2012, The DrizzlePac Handbook. (Baltimore, STScI)
+
+
+The Drizzle Library
+-------------------
+
+The Drizzle library is object-oriented and you use it by first creating an object of
+the ``Drizzle`` class. To create a new Drizzle output image, supply an Astropy
+WCS object representing the coordinate system of the output image.
+The other parameters are the linear pixel dimension described in the previous
+section, the drizzle kernel used, how each input image is scaled (by exposure
+time or time squared), and the pixel value set in the output image where the
+input images do not overlap.
+
+After creating a Drizzle object, you add one or more images by calling the
+``add_fits_file`` method. The arguments are the name of the FITS file containing
+the input image and optionally the name of a FITS file containing the pixel
+weighting. Both file names can be followed by an extension name or number in
+square brackets. Optionally you can pass the name of the header keywords
+containing the exposure time and units. Two units are understood: counts and
+cps (counts per second).
+
+The following function is a demonstration of how you can create a new output
+image::
+
+    def drizzle_demo_one(reference, outfile, infiles):
+        """
+        First demonstration of drizzle
+
+        Parameters
+        ==========
+        reference
+            A file containing the wcs of the output image
+
+        outfile
+            The name of the output image
+
+        infiles
+            The names of the input images to be combined
+        """
+        # Get the WCS for the output image
+        hdulist = fits.open(reference)
+        reference_wcs = wcs.WCS(hdulist[1].header)
+
+        # Initialize the output with the WCS
+        driz = drizzle.drizzle.Drizzle(outwcs=reference_wcs)
+
+        # Combine the input images into on drizzle image
+        for infile in infiles:
+            driz.add_fits_file(infile)
+
+        # Write the drizzled image out
+        driz.write(outfile)
+
+Optionally you can supply the input and weight images as Numpy arrays by using
+the ``add_image`` method. If you use this method, you must supply the extra
+information that would otherwise be read from the FITS image: The WCS
+of the input image, the exposure time, and image units.
+
+Here is an example of how you would call ``add_image``::
+
+    def drizzle_demo_two(reference, outfile, infiles):
+        """
+        Demonstration of drizzle with add image.
+
+        Parameters
+        ==========
+        reference
+            A file containing the wcs of the output image.
+
+        outfile
+            The name of the output image.
+
+        infiles
+            The names of the input images to be combined.
+        """
+        # Get the WCS for the output image
+        reflist = fits.open(reference)
+        reference_wcs = wcs.WCS(reflist[1].header)
+
+        # Initialize the output with the WCS
+        driz = drizzle.drizzle.Drizzle(outwcs=reference_wcs)
+
+        # Combine the input images into on drizzle image
+        for infile in infiles:
+            # Open the file and read the image and wcs
+            # This is a contrived example, we would not do this
+            # unless the data came from another source
+            # than a FITS file
+            imlist = fits.open(reference)
+            image = imlist[1].data
+            image_wcs = wcs.WCS(imlist[1].header)
+            driz.add_image(image, image_wcs)
+
+        # Write the drizzled image out
+        driz.write(outfile)
+
+After combining all the input images, you write the output image into a FITS
+file with the ``write`` method. You must pass the name of the output image and
+optionally the units. You can also supply a set of header cards to be added
+to the primary header of the output FITS file.
+
+You can also add more images to an existing Drizzle output file by creating
+a new Drizzle object and passing the existing output file name as the new
+object is created. In that case the output WCS and all
+other parameters are read from the file.
+
+Here is a demonstration of adding additional input images to a drizzled image::
+
+    def drizzle_demo_three(outfile, infiles):
+        """
+        Demonstration of drizzle and adding to an existing output.
+
+        Parameters
+        ==========
+        outfile
+            Name of output image that new files will be appended to.
+
+        infiles
+            The names of the input images to be added.
+        """
+        # Re-open the output file
+        driz = drizzle.drizzle.Drizzle(infile=outfile)
+
+        # Add the input images to the existing output image
+        for infile in infiles:
+            driz.add_fits_file(infile)
+
+        # Write the modified drizzled image out
+        driz.write(outfile)
+
+You can use the methods ``blot_fits_file`` and ``blot_image`` to transform the drizzled
+output image into another WCS. Most usually this is the
+coordinates of one of the input images and is used to identify cosmic rays or
+other defects. The two methods ``blot_fits_file`` and ``blot_image`` allow you to
+retrieve the WCS from the FITS file header or input it directly.
+The optional parameter ``interp`` allows you to selct the method used to resample
+the pixels on the new grid, and ``sincscl`` is used to scale the sinc function if one
+of the sinc interpolation methods is used. This function demonstrates how both
+methods are called::
+
+    def drizzle_demo_four(outfile, blotfile):
+        """
+        Demonstration of blot methods.
+
+        Parameters
+        ==========
+        outfile
+            Name of output image that will be converted.
+
+        blotfile
+            Name of image containing wcs to be transformed to.
+        """
+        # Open drizzle using the output file
+        # Transform it to another coordinate system
+        driz = drizzle.drizzle.Drizzle(infile=outfile)
+        driz.blot_fits_file(blotfile)
+        driz.write(outfile)
+
+        # Read the WCS and transform using it instead
+        # This is a contrived example
+        blotlist = fits.open(blotfile)
+        blot_wcs = wcs.WCS(blotlist[1].header)
+        driz = drizzle.drizzle.Drizzle(infile=outfile)
+        driz.blot_image(blot_wcs)
+        driz.write(outfile)
+
+The lower level function ``dodrizzle`` is present for backwards compatibility with
+the existing STScI DrizzlePac code and should not be used unless you are also
+concerned with this compatibility.

drizzle-1.15.0.dist-info/RECORD

@@ -0,0 +1,18 @@
+drizzle/__init__.py,sha256=7M-hCW6QcKqJl0bdkCixW08PBJzLdMz6UTTzz2CKbgc,271
+drizzle/calc_pixmap.py,sha256=pM4Wvsjzc_gzb7NR23kLoxQy426ZXZF07tq59qqfEyA,1702
+drizzle/cdrizzle.cp310-win_amd64.pyd,sha256=ShcSVecvN9Y0p3HI_bAFemSJcdTVeqSPFZG9qZ-LcfE,100352
+drizzle/doblot.py,sha256=Qr5FdfV9-GY93Do5Jb9VAX-Y7M4EusIzAwwneV76Ai4,2576
+drizzle/dodrizzle.py,sha256=3h8FE46FoHUdt9T4FjXlSOQvGU_OQZm3FRXX33I2XDM,6979
+drizzle/drizzle.py,sha256=jnsv5GUX-NZHJN3GQhkWmmxDp1QK9iSFeYDpgNpeVVY,23441
+drizzle/util.py,sha256=8qPA7C8nqRL7vAjJ3Ip6yLeaIauJXLtV9JBAzIDUNiY,5999
+drizzle/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+drizzle/tests/test_cdrizzle.py,sha256=JHwVwOQ-evOD1XMPyKStxODy3AGwzXa6PMDGJldmFik,714
+drizzle/tests/test_drizzle.py,sha256=pAEDodtD3DkeqdHaX_MUZjiPmTsDzBQk03idymgWPQY,21010
+drizzle/tests/test_file_io.py,sha256=z6deDDdwGog03wC96poDDWoqafB2cfyR9q0PJzAaJ_g,5094
+drizzle/tests/test_overlap_calc.py,sha256=0vtswuOXa2bP4GLm2c5q1tuIWdXePfZ_6Xd0-odKia0,7062
+drizzle/tests/test_pixmap.py,sha256=B8Xj0MjpeP6Tc2vIL7gV7kBDmyDdo5SEafxGHrTnESM,2131
+drizzle-1.15.0.dist-info/LICENSE.rst,sha256=sUXj5W73D9TcOw5ZXaDdcthYdY2b2dTJPsxBuZTOYWQ,1505
+drizzle-1.15.0.dist-info/METADATA,sha256=sRkBxOA3jsNoEtTX9RWCW0ug4jbHBdIIJ81G50_PxHA,17024
+drizzle-1.15.0.dist-info/WHEEL,sha256=5JPYeYl5ZdvdSkrGS4u21mmpPzpFx42qrXOSIgWf4pg,102
+drizzle-1.15.0.dist-info/top_level.txt,sha256=MA5uqwTj1sJBi-hCeQj9v3-sZ9nVUTe6bd_zGWTKy5A,8
+drizzle-1.15.0.dist-info/RECORD,,

drizzle-1.15.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: bdist_wheel (0.42.0)
+Root-Is-Purelib: false
+Tag: cp310-cp310-win_amd64
+

drizzle-1.15.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+drizzle