drizzle 2.0.1__cp310-cp310-win32.whl → 2.1.1__cp310-cp310-win32.whl

drizzle/resample.py

@@ -76,23 +76,24 @@ class Drizzle:
     information about which input image has contributed to the corresponding
     pixel in the resampled data array. Context image uses 32 bit integers to
     encode this information and hence it can keep track of only 32 input images.
-    First bit corresponds to the first input image, second bit corrsponds to the
-    second input image, and so on. We call this (0-indexed) order "context ID"
-    which is represented by the ``ctx_id`` parameter/property. If the number of
+    The first bit corresponds to the first input image, the second bit
+    corresponds to the second input image, and so on.
+    We call this (0-indexed) order "context ID" which is represented by
+    the ``ctx_id`` parameter/property. If the number of
     input images exceeds 32, then it is necessary to have multiple context
-    images ("planes") to hold information about all input images with the first
+    images ("planes") to hold information about all input images, with the first
     plane encoding which of the first 32 images contributed to the output data
-    pixel, second plane representing next 32 input images (number 33-64), etc.
-    For this reason, context array is either a 2D array (if the total number
-    of resampled images is less than 33) of the type `numpy.int32` and shape
-    ``(ny, nx)`` or a a 3D array of shape ``(np, ny, nx)`` where ``nx`` and
-    ``ny`` are dimensions of image's data. ``np`` is the number of "planes"
-    equal to ``(number of input images - 1) // 32 + 1``. If a bit at position
-    ``k`` in a pixel with coordinates ``(p, y, x)`` is 0 then input image number
-    ``32 * p + k`` (0-indexed) did not contribute to the output data pixel
-    with array coordinates ``(y, x)`` and if that bit is 1 then input image
-    number ``32 * p + k`` did contribute to the pixel ``(y, x)`` in the
-    resampled image.
+    pixel, the second plane representing next 32 input images (number 33-64),
+    etc. For this reason, context array is either a 2D array (if the total
+    number of resampled images is less than 33) of the type `numpy.int32` and
+    shape ``(ny, nx)`` or a a 3D array of shape ``(np, ny, nx)`` where ``nx``
+    and ``ny`` are dimensions of the image data. ``np`` is the number of
+    "planes" computed as ``(number of input images - 1) // 32 + 1``. If a bit at
+    position ``k`` in a pixel with coordinates ``(p, y, x)`` is 0, then input
+    image number ``32 * p + k`` (0-indexed) did not contribute to the output
+    data pixel with array coordinates ``(y, x)`` and if that bit is 1, then
+    input image number ``32 * p + k`` did contribute to the pixel ``(y, x)``
+    in the resampled image.
 
     As an example, let's assume we have 8 input images. Then, when ``out_ctx``
     pixel values are displayed using binary representation (and decimal in
@@ -413,7 +414,11 @@ class Drizzle:
                     )
 
         if out_img is None:
-            self._out_img = np.zeros(out_shape, dtype=np.float32)
+            if self._fillval.upper() in ["INDEF", "NAN"]:
+                fillval = np.nan
+            else:
+                fillval = float(self._fillval)
+            self._out_img = np.full(out_shape, fillval, dtype=np.float32)
         else:
             self._out_img = out_img
 
@@ -548,7 +553,7 @@ class Drizzle:
 
             self._alloc_output_arrays(
                 out_shape=self._out_shape,
-                max_ctx_id=max(self._max_ctx_id, self._ctx_id),
+                max_ctx_id=self._max_ctx_id,
                 out_img=None,
                 out_wht=None,
                 out_ctx=None,

drizzle/tests/helpers.py

@@ -56,40 +56,71 @@ def wcs_from_file(filename, ext=None, return_data=False, crpix_shift=None,
     """
     full_file_name = os.path.join(DATA_DIR, filename)
     path = os.path.join(DATA_DIR, full_file_name)
-    with fits.open(path) as hdu:
-        if ext is None:
-            for k, u in enumerate(hdu):
+
+    def get_shape(hdr):
+        naxis1 = hdr.get("WCSNAX1", hdr.get("NAXIS1"))
+        naxis2 = hdr.get("WCSNAX2", hdr.get("NAXIS2"))
+        if naxis1 is None or naxis2 is None:
+            return None
+        return (naxis2, naxis1)
+
+    def data_from_hdr(hdr, data=None, shape=None):
+        if data is not None:
+            return data
+        bitpix = hdr.get("BITPIX", -32)
+        dtype = fits.hdu.BITPIX2DTYPE[bitpix]
+        shape = get_shape(hdr) or shape
+        if shape is None:
+            return None
+        return np.zeros(shape, dtype=dtype)
+
+    if os.path.splitext(filename)[1] in [".hdr", ".txt"]:
+        hdul = None
+        hdr = fits.Header.fromfile(
+            path,
+            sep='\n',
+            endcard=False,
+            padding=False
+        )
+
+    else:
+        with fits.open(path) as fits_hdul:
+            hdul = fits.HDUList([hdu.copy() for hdu in fits_hdul])
+
+        if ext is None and hdul is not None:
+            for k, u in enumerate(hdul):
                 if "CTYPE1" in u.header:
                     ext = k
                     break
 
-        hdr = hdu[ext].header
-        naxis1 = hdr.get("WCSNAX1", hdr.get("NAXIS1"))
-        naxis2 = hdr.get("WCSNAX2", hdr.get("NAXIS2"))
-        if naxis1 is not None and naxis2 is not None:
-            shape = (naxis2, naxis1)
-            if hdu[ext].data is None:
-                hdu[ext].data = np.zeros(shape, dtype=np.float32)
-        else:
-            shape = None
-
-        if crpix_shift is not None and "CRPIX1" in hdr:
-            hdr["CRPIX1"] += crpix_shift[0]
-            hdr["CRPIX2"] += crpix_shift[1]
-
-        result = fits_wcs.WCS(hdr, hdu)
-        result.array_shape = shape
-
-        if wcs_type == "gwcs":
-            result = _gwcs_from_hst_fits_wcs(result)
-
-        if return_data:
-            result = (result, )
-            if not isinstance(return_data, (list, tuple)):
-                return_data = [ext]
-            for ext in return_data:
-                data = (hdu[ext].data, )
-                result = result + data
+        hdr = hdul[ext].header
+
+    if crpix_shift is not None and "CRPIX1" in hdr:
+        hdr["CRPIX1"] += crpix_shift[0]
+        hdr["CRPIX2"] += crpix_shift[1]
+
+    result = fits_wcs.WCS(hdr, hdul)
+    shape = get_shape(hdr)
+    result.array_shape = shape
+
+    if wcs_type == "gwcs":
+        result = _gwcs_from_hst_fits_wcs(result)
+
+    if return_data:
+        if hdul is None:
+            data = data_from_hdr(hdr, data=None, shape=shape)
+            return (result, data)
+
+        result = (result, )
+        if not isinstance(return_data, (list, tuple)):
+            return_data = [ext]
+        for ext in return_data:
+            data = data_from_hdr(
+                hdul[ext].header,
+                data=hdul[ext].data,
+                shape=shape
+            )
+            result = result + (data, )
 
     return result
 

drizzle/tests/test_overlap_calc.py

@@ -260,3 +260,27 @@ def test_intersection_case01():
     cp = clip_polygon(p, wnd)
 
     assert _is_poly_eq(cp, cp_ref)
+
+
+def test_intersection_case02():
+    # a real case of failure reported in #189
+    p = [
+        (-0.04000000000000009104, 1.5),
+        (2.73499999999999943157, 1.5),
+        (1.83500000000000018652, -0.5),
+        (-0.03999999999999998002, -0.5),
+    ]
+    wnd = [
+        (-0.5, -0.5), (3.5, -0.5), (3.5, 3.5), (-0.5, 3.5)
+    ]
+
+    cp_ref = [
+        (-0.04, 1.5),
+        (-0.04, -0.5),
+        (1.835, -0.5),
+        (2.735, 1.5),
+    ]
+
+    cp = clip_polygon(p, wnd)
+
+    assert _is_poly_eq(cp, cp_ref)

drizzle/tests/test_resample.py

@@ -5,6 +5,7 @@ import numpy as np
 import pytest
 
 from astropy import wcs
+from astropy.convolution import Gaussian2DKernel
 from drizzle import cdrizzle, resample, utils
 
 from .helpers import wcs_from_file
@@ -191,6 +192,57 @@ def make_grid_image(shape, spacing, value):
     return output_image
 
 
+@pytest.fixture(scope="module")
+def nrcb5_stars():
+    full_file_name = os.path.join(DATA_DIR, "nrcb5_sip_wcs.hdr")
+    path = os.path.join(DATA_DIR, full_file_name)
+
+    wcs, data = wcs_from_file(path, return_data=True)
+    dq = np.zeros(data.shape, dtype=np.int32)
+    wht = np.zeros(data.shape, dtype=np.float32)
+    np.random.seed(0)
+
+    patch_size = 21
+    p2 = patch_size // 2
+    # add border so that resampled partial pixels can be isolated
+    # in the segmentation:
+    border = 4
+    pwb = patch_size + border
+
+    fwhm2sigma = 2.0 * math.sqrt(2.0 * math.log(2.0))
+
+    ny, nx = data.shape
+
+    stars = []
+
+    for yc in range(border + p2, ny - pwb, pwb):
+        for xc in range(border + p2, nx - pwb, pwb):
+            sl = np.s_[yc - p2:yc + p2 + 1, xc - p2:xc + p2 + 1]
+            flux = 1.0 + 99.0 * np.random.random()
+            if np.random.random() > 0.7:
+                # uniform image
+                psf = np.full((patch_size, patch_size), flux)
+            else:
+                # "star":
+                fwhm = 1.5 + 1.5 * np.random.random()
+                sigma = fwhm / fwhm2sigma
+
+                psf = flux * Gaussian2DKernel(
+                    sigma,
+                    x_size=patch_size,
+                    y_size=patch_size
+                ).array
+            weight = 0.6 + 0.4 * np.random.random((patch_size, patch_size))
+            wflux = (psf * weight).sum()
+
+            data[sl] = psf
+            wht[sl] = weight
+            dq[sl] = 0
+            stars.append((xc, yc, wflux, sl))
+
+    return data, wht, dq, stars, wcs
+
+
 def test_drizzle_defaults():
     n = 200
     in_shape = (n, n)
@@ -234,6 +286,7 @@ def test_drizzle_defaults():
     assert driz.out_img[1, 2] == 1
     assert (driz.out_img[2, 1] - 2.0) < 1.0e-14
 
+
 @pytest.mark.parametrize(
     'kernel,test_image_type,max_diff_atol',
     [
@@ -303,7 +356,10 @@ def test_resample_kernel(tmpdir, kernel, test_image_type, max_diff_atol):
             scale=pscale_ratio,
         )
     else:
-        with pytest.warns(Warning):
+        with pytest.warns(
+            Warning,
+            match=f"Kernel '{kernel}' is not a flux-conserving kernel"
+        ):
             driz.add_image(
                 insci,
                 exptime=1.0,
@@ -434,7 +490,10 @@ def test_zero_input_weight(kernel, fc):
             fillstr='INDEF',
         )
     else:
-        with pytest.warns(Warning):
+        with pytest.warns(
+            Warning,
+            match=f"Kernel '{kernel}' is not a flux-conserving kernel"
+        ):
             cdrizzle.tdriz(
                 insci,
                 inwht,
@@ -708,7 +767,10 @@ def test_flux_conservation_nondistorted(kernel, fc):
             wtscale=1.0,
         )
     else:
-        with pytest.warns(Warning):
+        with pytest.warns(
+            Warning,
+            match=f"Kernel '{kernel}' is not a flux-conserving kernel"
+        ):
             cdrizzle.tdriz(
                 in_sci,
                 in_wht,
@@ -796,7 +858,10 @@ def test_flux_conservation_distorted(kernel, fc):
             wtscale=1.0,
         )
     else:
-        with pytest.warns(Warning):
+        with pytest.warns(
+            Warning,
+            match=f"Kernel '{kernel}' is not a flux-conserving kernel"
+        ):
             cdrizzle.tdriz(
                 in_sci,
                 in_wht,
@@ -821,6 +886,50 @@ def test_flux_conservation_distorted(kernel, fc):
     )
 
 
+@pytest.mark.parametrize("kernel", ["square", "turbo", "point"])
+@pytest.mark.parametrize("pscale_ratio", [0.55, 1.0, 1.2])
+def test_flux_conservation_distorted_distributed_sources(nrcb5_stars, kernel, pscale_ratio):
+    """ test aperture photometry """
+    insci, inwht, dq, stars, wcs = nrcb5_stars
+
+    suffix = f"{pscale_ratio}".replace(".", "p")
+    output_wcs = wcs_from_file(f"nrcb5_output_wcs_psr_{suffix}.hdr")
+
+    pixmap = utils.calc_pixmap(
+        wcs,
+        output_wcs,
+        wcs.array_shape,
+    )
+
+    driz = resample.Drizzle(
+        kernel=kernel,
+        out_shape=output_wcs.array_shape,
+        fillval=0.0,
+    )
+    driz.add_image(
+        insci,
+        exptime=1.0,
+        pixmap=pixmap,
+        weight_map=inwht,
+        scale=1,
+    )
+
+    # for efficiency, instead of doing this patch-by-patch,
+    # multiply resampled data by resampled image weight
+    out_data = driz.out_img * driz.out_wht
+
+    dim3 = (slice(None, None, None), )
+    for _, _, fin, sl in stars:
+        xyout = pixmap[sl + dim3]
+        xmin = int(np.floor(xyout[:, :, 0].min() - 0.5))
+        xmax = int(np.ceil(xyout[:, :, 0].max() + 1.5))
+        ymin = int(np.floor(xyout[:, :, 1].min() - 0.5))
+        ymax = int(np.ceil(xyout[:, :, 1].max() + 1.5))
+        fout = np.nansum(out_data[ymin:ymax, xmin:xmax])
+
+        assert np.allclose(fin, fout, rtol=1.0e-6, atol=0.0)
+
+
 def test_drizzle_exptime():
     n = 200
     in_shape = (n, n)
@@ -1042,7 +1151,7 @@ def test_resample_get_shape_from_pixmap():
         exptime=0.0,
     )
 
-    driz.add_image(in_sci, weight_map=in_wht, exptime=1.0, pixmap=pixmap)
+    driz.add_image(in_sci, weight_map=in_wht, exptime=0.1, pixmap=pixmap)
     assert driz.out_img.shape == in_shape
 
 
@@ -1098,3 +1207,144 @@ def test_resample_inconsistent_output():
             out_wht=out_wht,
         )
     assert str(err_info.value).startswith("Inconsistent data shapes specified")
+
+
+def test_resample_disable_ctx():
+    n = 20
+    in_shape = (n, n)
+
+    pixmap = np.dstack(np.indices(in_shape, dtype=np.float64)[::-1])
+
+    # simulate constant data:
+    in_sci = np.ones(in_shape, dtype=np.float32)
+
+    driz = resample.Drizzle(
+        disable_ctx=True,
+    )
+
+    driz.add_image(in_sci, exptime=1.0, pixmap=pixmap)
+
+
+@pytest.mark.parametrize(
+    "fillval", ["NaN", "INDEF", "", None]
+)
+def test_nan_fillval(fillval):
+    driz = resample.Drizzle(
+        kernel='square',
+        fillval=fillval,
+        out_shape=(20, 20)
+    )
+
+    assert np.all(np.isnan(driz.out_img))
+
+
+def test_resample_edge_sgarea_bug():
+    """
+    Test from https://github.com/spacetelescope/drizzle/issues/187
+
+    """
+    pixmap = (np.array([
+        [
+            [0.31887051, 1.],
+            [1.01898591, 1.],
+            [1.71909665, 1.],
+        ],
+        [
+            [0.31591881, 0.],
+            [1.0160342312345672, 0.],
+            [1.716145, 0.],
+        ]
+    ], dtype="f8"))
+
+    in_shape = pixmap.shape[:2]
+    img = np.full(in_shape, 42, dtype=np.float32)
+    out_shape = (4, 4)
+
+    driz = resample.Drizzle(
+        kernel='square',
+        fillval='nan',
+        out_shape=out_shape,
+        disable_ctx=True,
+    )
+
+    driz.add_image(
+        img,
+        exptime=11.776,
+        in_units='cps',
+        pixfrac=1.0,
+        pixmap=pixmap,
+        scale=1.0,
+        wht_scale=1.0,
+    )
+    # expected pixels should be close to 42
+    np.testing.assert_allclose(driz.out_img[:2, :3], img[0, 0], rtol=1e-6)
+
+    # other values should be nan
+    np.testing.assert_equal(driz.out_img[:, 3:], np.nan)
+    np.testing.assert_equal(driz.out_img[2:], np.nan)
+
+
+def test_resample_edge_collinear():
+    """
+    Test that resample does not crash when the input image is smaller than the
+    output image, and the edges of the two images are nearly collinear.
+
+    Test based on the example from
+    https://github.com/spacetelescope/drizzle/issues/189#issue-3196294879
+
+    """
+    pixmap = (np.array([
+        [
+            [0.31, 1.0],
+            [1.01, 1.0],
+            [2.01, 1.0],
+        ],
+        [
+            [0.31, 0.],
+            [1.01, 0.],
+            [1.71, 0.],
+        ]
+    ], dtype="f8"))
+
+    in_shape = pixmap.shape[:2]
+    img = np.full(in_shape, np.pi, dtype=np.float32)
+    in_flux = np.sum(img)
+    out_shape = (4, 4)
+
+    driz = resample.Drizzle(
+        kernel='square',
+        fillval='nan',
+        out_shape=out_shape,
+        disable_ctx=True,
+    )
+
+    driz.add_image(
+        img,
+        exptime=11.776,
+        in_units='cps',
+        pixfrac=1.0,
+        pixmap=pixmap,
+        scale=1.0,
+        wht_scale=1.0,
+    )
+
+    out_flux = np.nansum(driz.out_img * driz.out_wht)
+
+    # Given this pixmap, the entire input image should fit within the output
+    # image. There should be at least 7 pixels with finite values in the output
+    # image. We can get more than 7 pixels with finite values due to rounding
+    # errors when computing polygon intersections (those "extra" pixels should)
+    # have very small weights.
+    assert np.sum(driz.out_wht > 1e-30) == 7
+    assert np.sum(np.isfinite(driz.out_img)) >= 7
+    # output image intensity must be equal to the input image intensity:
+    assert np.allclose(
+        driz.out_img[np.isfinite(driz.out_img)],
+        img[0, 0],
+        rtol=0,
+        atol=1e-6
+    )
+    # flux in the output image should be equal to the flux in the input image:
+    assert np.allclose(out_flux, in_flux, rtol=1e-6, atol=0.0)
+    # area of the signal in the input image:
+    assert np.allclose(np.sum(driz.out_wht), 6.0, rtol=0, atol=1.0e-6)

drizzle/tests/test_utils.py

@@ -2,6 +2,7 @@ import numpy as np
 import pytest
 from numpy.testing import assert_almost_equal, assert_equal
 
+from drizzle.tests.helpers import wcs_from_file
 from drizzle.utils import (
     _estimate_pixel_scale,
     calc_pixmap,
@@ -9,8 +10,6 @@ from drizzle.utils import (
     estimate_pixel_scale_ratio,
 )
 
-from .helpers import wcs_from_file
-
 
 def test_map_rectangular():
     """

drizzle/utils.py

@@ -96,7 +96,7 @@ def calc_pixmap(wcs_from, wcs_to, shape=None, disable_bbox="to"):
                 bbox_from = (bbox_from, )
             if nd > 1:
                 shape = tuple(
-                    int(math.ceil(lim[1] + 0.5)) for lim in bbox_from[::-1]
+                    math.ceil(lim[1] + 0.5) for lim in bbox_from[::-1]
                 )
 
     if shape is None:

{drizzle-2.0.1.dist-info → drizzle-2.1.1.dist-info}/METADATA

@@ -1,40 +1,8 @@
-Metadata-Version: 2.2
+Metadata-Version: 2.4
 Name: drizzle
-Version: 2.0.1
+Version: 2.1.1
 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/
@@ -56,6 +24,7 @@ Requires-Dist: sphinx-automodapi; extra == "docs"
 Requires-Dist: sphinx-rtd-theme; extra == "docs"
 Requires-Dist: matplotlib; extra == "docs"
 Requires-Dist: pytest-doctestplus; extra == "docs"
+Dynamic: license-file
 
 drizzle Documentation
 =====================
@@ -108,8 +77,8 @@ Requirements
 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]_
+This section has been extracted from Chapter 3 of
+`The DrizzlePac Handbook <https://hst-docs.stsci.edu/drizzpac>`_ [Driz2025]_
 
 There are a family of linear reconstruction techniques that, at two opposite
 extremes, are represented by the interlacing and shift-and-add techniques, with
@@ -200,4 +169,4 @@ for identifying cosmic rays in the original image. Blot requires the user
 to provide the world coordinate system (WCS)-based transformations in the
 form of a pixel map array as input.
 
-.. [Driz2012] Gonzaga, S., Hack, W., Fruchter, A., Mack, J., eds. 2012, The DrizzlePac Handbook. (Baltimore, STScI)
+.. [Driz2025] Anand, G. S., Mack, J., et al., 2025, “The DrizzlePac Handbook”, Version 3.0, (Baltimore: STScI)

drizzle-2.1.1.dist-info/RECORD

@@ -0,0 +1,16 @@
+drizzle/__init__.py,sha256=hMpqmjPhrUWTRU0eXNOcrpiqQFGp4lf9opY8FXqLLEQ,325
+drizzle/cdrizzle.cp310-win32.pyd,sha256=7x7tqGMYIf-Y5kDmsE_y9OhxpE3hVipeU3YFxbZmMnk,88064
+drizzle/resample.py,sha256=lps_nPPcEtOID3Y1oJALaFXQ8AyhFrmWu70O0z-tDak,29157
+drizzle/util.py,sha256=os9wHm1JkKiG5jtnNCZAXG3vnnXxLHBpi8OTWsiPI7k,845
+drizzle/utils.py,sha256=HvRPduBswRwi3OLN48tjv7y7XkP_sfcbNtxmcrfIDy0,10841
+drizzle/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+drizzle/tests/helpers.py,sha256=vD2uBLKTlgNXeLdof7kCdrOJRTQ8HQEQDvUChqB1PSQ,6673
+drizzle/tests/test_cdrizzle.py,sha256=utepqMiY8xtgQ8gBRBHwnlMhbBB1pq1xE4spf-wO7Kw,726
+drizzle/tests/test_overlap_calc.py,sha256=umROaVBJQUVozJUyTB52oPaV3GVkcLiNhAr4z_9JZe0,7598
+drizzle/tests/test_resample.py,sha256=SKhqAbEjKEIxUBKT3gcyfL8LiA9KsbTFt5rQHL-e40k,38856
+drizzle/tests/test_utils.py,sha256=h24pE4cM-_FPPpZ9jBc9IdWKvKwFoTiA2ENeJx0oN6Q,7702
+drizzle-2.1.1.dist-info/licenses/LICENSE.rst,sha256=sUXj5W73D9TcOw5ZXaDdcthYdY2b2dTJPsxBuZTOYWQ,1505
+drizzle-2.1.1.dist-info/METADATA,sha256=MXMPJY-Vlw615zObvlnGrTx87ff2p7nVM0YXqfjuGGU,9104
+drizzle-2.1.1.dist-info/WHEEL,sha256=GWZF0cboiU4MhsG0baPl8rrtCaXFSLW25384gp3vddM,97
+drizzle-2.1.1.dist-info/top_level.txt,sha256=MA5uqwTj1sJBi-hCeQj9v3-sZ9nVUTe6bd_zGWTKy5A,8
+drizzle-2.1.1.dist-info/RECORD,,

{drizzle-2.0.1.dist-info → drizzle-2.1.1.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (75.8.0)
+Generator: setuptools (80.9.0)
 Root-Is-Purelib: false
 Tag: cp310-cp310-win32
 

drizzle-2.0.1.dist-info/RECORD

@@ -1,16 +0,0 @@
-drizzle/__init__.py,sha256=hMpqmjPhrUWTRU0eXNOcrpiqQFGp4lf9opY8FXqLLEQ,325
-drizzle/cdrizzle.cp310-win32.pyd,sha256=1ayhjo95oxpxy8ocjMaFNi1Gtaio81J8Mcik9kz06Ls,86016
-drizzle/resample.py,sha256=LXc3TxaXvOd05zrszMa94JZbMSu7T3kDn4zoL3N7yeI,28982
-drizzle/util.py,sha256=os9wHm1JkKiG5jtnNCZAXG3vnnXxLHBpi8OTWsiPI7k,845
-drizzle/utils.py,sha256=hz6TVSb5dWIVw3P28EeeSc6PjVJNy4JAG5tB1v1yIrE,10846
-drizzle/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-drizzle/tests/helpers.py,sha256=BF_IbAwBZFgrTglw33Mgw56xfKYqNJXVTtjCwUB_U98,5887
-drizzle/tests/test_cdrizzle.py,sha256=utepqMiY8xtgQ8gBRBHwnlMhbBB1pq1xE4spf-wO7Kw,726
-drizzle/tests/test_overlap_calc.py,sha256=ucwDL9fd8NVAxTdz-sWum_uobhm-TGkCr2yl69BKiC4,7062
-drizzle/tests/test_resample.py,sha256=13UfYaGtTT2utQfF7j_8pQXzC51RFZ8EpRLFYSdz1MM,31600
-drizzle/tests/test_utils.py,sha256=s4-z4ZMTcoIUyxHW0pMRpQB2GiA1lbfuNLQzkOgflp8,7691
-drizzle-2.0.1.dist-info/LICENSE.rst,sha256=sUXj5W73D9TcOw5ZXaDdcthYdY2b2dTJPsxBuZTOYWQ,1505
-drizzle-2.0.1.dist-info/METADATA,sha256=2G_rWumBwJpBy9MC7qc_c7CHA3qj_4RLxIHehazIIdM,10894
-drizzle-2.0.1.dist-info/WHEEL,sha256=rLq6zy99NFadnn104_KE5z0qCJfRTCVsMafVXwuXNlE,97
-drizzle-2.0.1.dist-info/top_level.txt,sha256=MA5uqwTj1sJBi-hCeQj9v3-sZ9nVUTe6bd_zGWTKy5A,8
-drizzle-2.0.1.dist-info/RECORD,,