large-image-source-tiff 1.27.5.dev6__py3-none-any.whl → 1.30.7.dev10__py3-none-any.whl

large_image_source_tiff/__init__.py

@@ -30,7 +30,9 @@ import tifftools
 
 from large_image.cache_util import LruCacheMetaclass, methodcache
 from large_image.constants import TILE_FORMAT_NUMPY, TILE_FORMAT_PIL, SourcePriority
-from large_image.exceptions import TileSourceError, TileSourceFileNotFoundError
+from large_image.exceptions import (TileSourceError,
+                                    TileSourceFileNotFoundError,
+                                    TileSourceMalformedError)
 from large_image.tilesource import FileTileSource, nearPowerOfTwo
 
 from . import tiff_reader
@@ -63,6 +65,7 @@ class TiffFileTileSource(FileTileSource, metaclass=LruCacheMetaclass):
         'ptif': SourcePriority.PREFERRED,
         'ptiff': SourcePriority.PREFERRED,
         'qptiff': SourcePriority.PREFERRED,
+        'svs': SourcePriority.MEDIUM,
     }
     mimeTypes = {
         None: SourcePriority.FALLBACK,
@@ -72,6 +75,7 @@ class TiffFileTileSource(FileTileSource, metaclass=LruCacheMetaclass):
     }
 
     _maxAssociatedImageSize = 8192
+    _maxUntiledImage = 4096
 
     def __init__(self, path, **kwargs):  # noqa
         """
@@ -84,18 +88,20 @@ class TiffFileTileSource(FileTileSource, metaclass=LruCacheMetaclass):
 
         self._largeImagePath = str(self._getLargeImagePath())
 
+        lastException = None
         try:
             self._initWithTiffTools()
             return
+        except TileSourceMalformedError:
+            raise
         except Exception as exc:
             self.logger.debug('Cannot read with tifftools route; %r', exc)
+            lastException = exc
 
         alldir = []
         try:
             if hasattr(self, '_info'):
                 alldir = self._scanDirectories()
-            else:
-                lastException = 'Could not parse file with tifftools'
         except IOOpenTiffError:
             msg = 'File cannot be opened via tiff source.'
             raise TileSourceError(msg)
@@ -135,7 +141,7 @@ class TiffFileTileSource(FileTileSource, metaclass=LruCacheMetaclass):
                 continue
             # If a layer is a multiple of the tile size, the number of tiles
             # should be a power of two rounded up from the primary.
-            if (not (td.imageWidth % td.tileWidth) and not (td.imageHeight % td.tileHeight)):
+            if not (td.imageWidth % td.tileWidth) and not (td.imageHeight % td.tileHeight):
                 htw = highest.imageWidth // td.tileWidth
                 hth = highest.imageHeight // td.tileHeight
                 ttw = td.imageWidth // td.tileWidth
@@ -156,7 +162,7 @@ class TiffFileTileSource(FileTileSource, metaclass=LruCacheMetaclass):
             tifftools.constants.SampleFormat[sampleformat or 1].name,
             bitspersample,
         ))
-        self._bandCount = highest._tiffInfo.get('samplesperpixel')
+        self._bandCount = highest._tiffInfo.get('samplesperpixel', 1)
         # Sort the directories so that the highest resolution is the last one;
         # if a level is missing, put a None value in its place.
         self._tiffDirectories = [directories.get(key) for key in
@@ -251,8 +257,13 @@ class TiffFileTileSource(FileTileSource, metaclass=LruCacheMetaclass):
         """
         sizeX = ifd['tags'][tifftools.Tag.ImageWidth.value]['data'][0]
         sizeY = ifd['tags'][tifftools.Tag.ImageLength.value]['data'][0]
-        tileWidth = baseifd['tags'][tifftools.Tag.TileWidth.value]['data'][0]
-        tileHeight = baseifd['tags'][tifftools.Tag.TileLength.value]['data'][0]
+        if tifftools.Tag.TileWidth.value in baseifd['tags']:
+            tileWidth = baseifd['tags'][tifftools.Tag.TileWidth.value]['data'][0]
+            tileHeight = baseifd['tags'][tifftools.Tag.TileLength.value]['data'][0]
+        else:
+            tileWidth = sizeX
+            tileHeight = baseifd['tags'][tifftools.Tag.RowsPerStrip.value]['data'][0]
+
         for tag in {
                 tifftools.Tag.SamplesPerPixel.value,
                 tifftools.Tag.BitsPerSample.value,
@@ -297,7 +308,7 @@ class TiffFileTileSource(FileTileSource, metaclass=LruCacheMetaclass):
         directories are the same size and format; all non-tiled directories are
         treated as associated images.
         """
-        dir0 = self.getTiffDir(0)
+        dir0 = self.getTiffDir(0, mustBeTiled=None)
         self.tileWidth = dir0.tileWidth
         self.tileHeight = dir0.tileHeight
         self.sizeX = dir0.imageWidth
@@ -311,21 +322,26 @@ class TiffFileTileSource(FileTileSource, metaclass=LruCacheMetaclass):
             tifftools.constants.SampleFormat[sampleformat or 1].name,
             bitspersample,
         ))
-        self._bandCount = dir0._tiffInfo.get('samplesperpixel')
+        self._bandCount = dir0._tiffInfo.get('samplesperpixel', 1)
         info = _cached_read_tiff(self._largeImagePath)
         self._info = info
         frames = []
         associated = []  # for now, a list of directories
-        curframe = -1
+        used_subifd = False
         for idx, ifd in enumerate(info['ifds']):
             # if not tiles, add to associated images
             if tifftools.Tag.tileWidth.value not in ifd['tags']:
-                associated.append(idx)
+                associated.append((idx, False))
                 continue
-            level = self._levelFromIfd(ifd, info['ifds'][0])
+            try:
+                level = self._levelFromIfd(ifd, info['ifds'][0])
+            except TileSourceError:
+                if idx and used_subifd:
+                    associated.append((idx, True))
+                    continue
+                raise
             # if the same resolution as the main image, add a frame
             if level == self.levels - 1:
-                curframe += 1
                 frames.append({'dirs': [None] * self.levels})
                 frames[-1]['dirs'][-1] = (idx, 0)
                 try:
@@ -358,15 +374,52 @@ class TiffFileTileSource(FileTileSource, metaclass=LruCacheMetaclass):
                     if len(subifds) != 1:
                         msg = 'When stored in subifds, each subifd should be a single ifd.'
                         raise TileSourceError(msg)
-                    level = self._levelFromIfd(subifds[0], info['ifds'][0])
+                    if (tifftools.Tag.StripOffsets.value not in subifds[0]['tags'] and
+                            tifftools.Tag.TileOffsets.value not in subifds[0]['tags']):
+                        msg = 'Subifd has no strip or tile offsets.'
+                        raise TileSourceMalformedError(msg)
+                    try:
+                        level = self._levelFromIfd(subifds[0], info['ifds'][0])
+                    except Exception:
+                        break
                     if level < self.levels - 1 and frames[-1]['dirs'][level] is None:
                         frames[-1]['dirs'][level] = (idx, subidx + 1)
+                        used_subifd = True
                     else:
                         msg = 'Tile layers are in a surprising order'
                         raise TileSourceError(msg)
+        # If we have a single untiled ifd that is "small", use it
+        if tifftools.Tag.tileWidth.value not in info['ifds'][0]['tags']:
+            if (
+                self.sizeX > self._maxUntiledImage or self.sizeY > self._maxUntiledImage or
+                (len(info['ifds']) != 1 or tifftools.Tag.SubIfd.value in ifd['tags']) or
+                (tifftools.Tag.ImageDescription.value in ifd['tags'] and
+                 'ImageJ' in ifd['tags'][tifftools.Tag.ImageDescription.value]['data'])
+            ):
+                msg = 'A tiled TIFF is required.'
+                raise ValidationTiffError(msg)
+            associated = []
+            level = self._levelFromIfd(ifd, info['ifds'][0])
+            frames.append({'dirs': [None] * self.levels})
+            frames[-1]['dirs'][-1] = (idx, 0)
+            try:
+                frameMetadata = json.loads(
+                    ifd['tags'][tifftools.Tag.ImageDescription.value]['data'])
+                for key in {'channels', 'frame'}:
+                    if key in frameMetadata:
+                        frames[-1][key] = frameMetadata[key]
+            except Exception:
+                pass
+            if tifftools.Tag.ICCProfile.value in ifd['tags']:
+                if not hasattr(self, '_iccprofiles'):
+                    self._iccprofiles = []
+                while len(self._iccprofiles) < len(frames) - 1:
+                    self._iccprofiles.append(None)
+                self._iccprofiles.append(ifd['tags'][
+                    tifftools.Tag.ICCProfile.value]['data'])
         self._associatedImages = {}
-        for dirNum in associated:
-            self._addAssociatedImage(dirNum)
+        for dirNum, isTiled in associated:
+            self._addAssociatedImage(dirNum, isTiled)
         self._frames = frames
         self._tiffDirectories = [
             self.getTiffDir(
@@ -448,7 +501,7 @@ class TiffFileTileSource(FileTileSource, metaclass=LruCacheMetaclass):
                 frame.setdefault('frame', {})
                 frame['frame']['IndexC'] = idx
 
-    def _addAssociatedImage(self, directoryNum, mustBeTiled=False, topImage=None):
+    def _addAssociatedImage(self, directoryNum, mustBeTiled=False, topImage=None, imageId=None):
         """
         Check if the specified TIFF directory contains an image with a sensible
         image description that can be used as an ID.  If so, and if the image
@@ -459,6 +512,7 @@ class TiffFileTileSource(FileTileSource, metaclass=LruCacheMetaclass):
            untiled images.
         :param topImage: if specified, add image-embedded metadata to this
            image.
+        :param imageId: if specified, use this as the image name.
         """
         try:
             associated = self.getTiffDir(directoryNum, mustBeTiled)
@@ -472,6 +526,8 @@ class TiffFileTileSource(FileTileSource, metaclass=LruCacheMetaclass):
                 id = 'dir%d' % directoryNum
                 if not len(self._associatedImages):
                     id = 'macro'
+            if imageId:
+                id = imageId
             if not id and not mustBeTiled:
                 id = {1: 'label', 9: 'macro'}.get(associated._tiffInfo.get('subfiletype'))
             if not isinstance(id, str):
@@ -483,7 +539,7 @@ class TiffFileTileSource(FileTileSource, metaclass=LruCacheMetaclass):
                     associated._pixelInfo['width'] <= self._maxAssociatedImageSize and
                     associated._pixelInfo['height'] <= self._maxAssociatedImageSize and
                     id not in self._associatedImages):
-                image = associated._tiffFile.read_image()
+                image = associated.read_image()
                 # Optrascan scanners store xml image descriptions in a "tiled
                 # image".  Check if this is the case, and, if so, parse such
                 # data
@@ -630,20 +686,16 @@ class TiffFileTileSource(FileTileSource, metaclass=LruCacheMetaclass):
         else:
             dir = self._tiffDirectories[z]
         try:
-            allowStyle = True
             if dir is None:
                 try:
                     if not kwargs.get('inSparseFallback'):
-                        tile = self._getTileFromEmptyLevel(x, y, z, **kwargs)
+                        tile, format = self._getTileFromEmptyLevel(x, y, z, **kwargs)
                     else:
                         raise IOTiffError('Missing z level %d' % z)
                 except Exception:
                     if sparseFallback:
                         raise IOTiffError('Missing z level %d' % z)
-                    else:
-                        raise
-                allowStyle = False
-                format = TILE_FORMAT_PIL
+                    raise
             else:
                 tile = dir.getTile(x, y, asarray=numpyAllowed == 'always')
                 format = 'JPEG'
@@ -652,7 +704,7 @@ class TiffFileTileSource(FileTileSource, metaclass=LruCacheMetaclass):
             if isinstance(tile, np.ndarray):
                 format = TILE_FORMAT_NUMPY
             return self._outputTile(tile, format, x, y, z, pilImageAllowed,
-                                    numpyAllowed, applyStyle=allowStyle, **kwargs)
+                                    numpyAllowed, **kwargs)
         except InvalidOperationTiffError as e:
             raise TileSourceError(e.args[0])
         except IOTiffError as e:
@@ -701,7 +753,7 @@ class TiffFileTileSource(FileTileSource, metaclass=LruCacheMetaclass):
             else:
                 image = PIL.Image.new('RGBA', (self.tileWidth, self.tileHeight))
             return self._outputTile(image, TILE_FORMAT_PIL, x, y, z, pilImageAllowed,
-                                    numpyAllowed, applyStyle=False, **kwargs)
+                                    numpyAllowed, **kwargs)
         raise TileSourceError('Internal I/O failure: %s' % exception.args[0])
 
     def _nonemptyLevelsList(self, frame=0):
@@ -726,7 +778,7 @@ class TiffFileTileSource(FileTileSource, metaclass=LruCacheMetaclass):
         """
         imageList = set(self._associatedImages)
         for td in self._tiffDirectories:
-            if td is not None:
+            if td is not None and td is not False:
                 imageList |= set(td._embeddedImages)
         return sorted(imageList)
 
@@ -741,11 +793,11 @@ class TiffFileTileSource(FileTileSource, metaclass=LruCacheMetaclass):
         # _associatedImages.  There are some sample files where libtiff's
         # read_image fails to read the _associatedImage properly because of
         # separated jpeg information.  For the samples we currently have,
-        # preferring the _embeddedImages is sufficient, but if find other files
-        # with seemingly bad associated images, we may need to read them with a
-        # more complex process than read_image.
+        # preferring the _embeddedImages is sufficient, but if we find other
+        # files with seemingly bad associated images, we may need to read them
+        # with a more complex process than read_image.
         for td in self._tiffDirectories:
-            if td is not None and imageKey in td._embeddedImages:
+            if td is not None and td is not False and imageKey in td._embeddedImages:
                 return PIL.Image.open(io.BytesIO(base64.b64decode(td._embeddedImages[imageKey])))
         if imageKey in self._associatedImages:
             return PIL.Image.fromarray(self._associatedImages[imageKey])

large_image_source_tiff/tiff_reader.py

@@ -121,7 +121,12 @@ class TiledTiffDirectory:
         self._tileLock = threading.RLock()
 
         self._open(filePath, directoryNum, subDirectoryNum)
-        self._loadMetadata()
+        try:
+            self._loadMetadata()
+        except Exception:
+            self.logger.exception('Could not parse tiff metadata')
+            raise IOOpenTiffError(
+                'Could not open TIFF file: %s' % filePath)
         self.logger.debug(
             'TiffDirectory %d:%d Information %r',
             directoryNum, subDirectoryNum or 0, self._tiffInfo)
@@ -207,8 +212,8 @@ class TiledTiffDirectory:
         # the create_image.py script, such as flatten or colourspace.  These
         # should only be done if necessary, which would require the conversion
         # job to check output and perform subsequent processing as needed.
-        if (not self._tiffInfo.get('samplesperpixel') or
-                self._tiffInfo.get('samplesperpixel') < 1):
+        if (not self._tiffInfo.get('samplesperpixel', 1) or
+                self._tiffInfo.get('samplesperpixel', 1) < 1):
             msg = 'Only RGB and greyscale TIFF files are supported'
             raise ValidationTiffError(msg)
 
@@ -442,12 +447,11 @@ class TiledTiffDirectory:
 
         if tileByteCountsLibtiffType == libtiff_ctypes.TIFFDataType.TIFF_LONG8:
             return ctypes.c_uint64
-        elif tileByteCountsLibtiffType == \
+        if tileByteCountsLibtiffType == \
                 libtiff_ctypes.TIFFDataType.TIFF_SHORT:
             return ctypes.c_uint16
-        else:
-            raise IOTiffError(
-                'Invalid type for TIFFTAG_TILEBYTECOUNTS: %s' % tileByteCountsLibtiffType)
+        raise IOTiffError(
+            'Invalid type for TIFFTAG_TILEBYTECOUNTS: %s' % tileByteCountsLibtiffType)
 
     def _getJpegFrameSize(self, tileNum):
         """
@@ -524,10 +528,10 @@ class TiledTiffDirectory:
         if bytesRead == -1:
             msg = 'Failed to read raw tile'
             raise IOTiffError(msg)
-        elif bytesRead < rawTileSize:
+        if bytesRead < rawTileSize:
             msg = 'Buffer underflow when reading tile'
             raise IOTiffError(msg)
-        elif bytesRead > rawTileSize:
+        if bytesRead > rawTileSize:
             # It's unlikely that this will ever occur, but incomplete reads will
             # be checked for by looking for the JPEG end marker
             msg = 'Buffer overflow when reading tile'
@@ -607,7 +611,7 @@ class TiledTiffDirectory:
             self._tiffInfo.get('bitspersample'),
             self._tiffInfo.get('sampleformat') if self._tiffInfo.get(
                 'sampleformat') is not None else libtiff_ctypes.SAMPLEFORMAT_UINT)
-        image = np.empty((th, tw, self._tiffInfo['samplesperpixel']),
+        image = np.empty((th, tw, self._tiffInfo.get('samplesperpixel', 1)),
                          dtype=_ctypesFormattbl[format])
         imageBuffer = image.ctypes.data_as(ctypes.POINTER(ctypes.c_char))
         if self._tiffInfo.get('istiled'):
@@ -635,7 +639,7 @@ class TiledTiffDirectory:
             raise IOTiffError(
                 'Read an unexpected number of bytes from an encoded tile' if readSize >= 0 else
                 'Failed to read from an encoded tile')
-        if (self._tiffInfo.get('samplesperpixel') == 3 and
+        if (self._tiffInfo.get('samplesperpixel', 1) == 3 and
                 self._tiffInfo.get('photometric') == libtiff_ctypes.PHOTOMETRIC_YCBCR):
             if self._tiffInfo.get('bitspersample') == 16:
                 image = np.floor_divide(image, 256).astype(np.uint8)
@@ -783,11 +787,13 @@ class TiledTiffDirectory:
 
         if (not self._tiffInfo.get('istiled') or
                 self._tiffInfo.get('compression') not in {
-                    libtiff_ctypes.COMPRESSION_JPEG, 33003, 33005, 34712} or
+                    libtiff_ctypes.COMPRESSION_JPEG, 33003, 33004, 33005, 34712} or
                 self._tiffInfo.get('bitspersample') != 8 or
                 self._tiffInfo.get('sampleformat') not in {
                     None, libtiff_ctypes.SAMPLEFORMAT_UINT} or
-                (asarray and self._tiffInfo.get('compression') not in {33003, 33005, 34712} and (
+                (asarray and self._tiffInfo.get('compression') not in {
+                    33003, 33004, 33005, 34712,
+                } and (
                     self._tiffInfo.get('compression') != libtiff_ctypes.COMPRESSION_JPEG or
                     self._tiffInfo.get('photometric') != libtiff_ctypes.PHOTOMETRIC_YCBCR))):
             return self._getUncompressedTile(tileNum)
@@ -803,9 +809,18 @@ class TiledTiffDirectory:
             # Write JPEG End Of Image marker
             imageBuffer.write(b'\xff\xd9')
             return imageBuffer.getvalue()
-        # Get the whole frame, which is in a JPEG or JPEG 2000 format, and
+        # Get the whole frame, which is in a JPEG or JPEG 2000 format
+        frame = self._getJpegFrame(tileNum, True)
+        # For JP2K, see if we can convert it faster than PIL
+        if self._tiffInfo.get('compression') in {33003, 33004, 33005, 34712}:
+            try:
+                import openjpeg
+
+                return openjpeg.decode(frame)
+            except Exception:
+                pass
         # convert it to a PIL image
-        imageBuffer.write(self._getJpegFrame(tileNum, True))
+        imageBuffer.write(frame)
         image = PIL.Image.open(imageBuffer)
         # Converting the image mode ensures that it gets loaded once and is in
         # a form we expect.  If this isn't done, then PIL can load the image
@@ -822,7 +837,7 @@ class TiledTiffDirectory:
         self._embeddedImages = {}
 
         if not meta:
-            return
+            return None
         if not isinstance(meta, str):
             meta = meta.decode(errors='ignore')
         try:
@@ -844,7 +859,7 @@ class TiledTiffDirectory:
                         meta.split('|MPP = ', 1)[1].split('|')[0].strip()) * 0.001
                 except Exception:
                     pass
-            return
+            return None
         try:
             image = xml.find(
                 ".//DataObject[@ObjectType='DPScannedImage']")
@@ -880,3 +895,26 @@ class TiledTiffDirectory:
         except Exception:
             pass
         return True
+
+    def read_image(self):
+        """
+        Use the underlying _tiffFile to read an image.  But, if it is in a jp2k
+        encoding, read the raw data and convert it.
+        """
+        if self._tiffInfo.get('compression') not in {33003, 33004, 33005, 34712}:
+            return self._tiffFile.read_image()
+        output = None
+        for yidx, y in enumerate(range(0, self.imageHeight, self.tileHeight)):
+            for xidx, x in enumerate(range(0, self.imageWidth, self.tileWidth)):
+                tile = self.getTile(xidx, yidx, asarray=True)
+                if len(tile.shape) == 2:
+                    tile = tile[:, :, np.newaxis]
+                if output is None:
+                    output = np.zeros(
+                        (self.imageHeight, self.imageWidth, tile.shape[2]), dtype=tile.dtype)
+                if tile.shape[0] > self.imageHeight - y:
+                    tile = tile[:self.imageHeight - y, :, :]
+                if tile.shape[1] > self.imageWidth - x:
+                    tile = tile[:, :self.imageWidth - x, :]
+                output[y:y + tile.shape[0], x:x + tile.shape[1], :] = tile
+        return output

{large_image_source_tiff-1.27.5.dev6.dist-info → large_image_source_tiff-1.30.7.dev10.dist-info}/METADATA

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.2
 Name: large-image-source-tiff
-Version: 1.27.5.dev6
+Version: 1.30.7.dev10
 Summary: A TIFF tilesource for large_image.
 Home-page: https://github.com/girder/large_image
 Author: Kitware, Inc.
@@ -15,13 +15,29 @@ 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
 Requires-Python: >=3.8
+Description-Content-Type: text/x-rst
 License-File: LICENSE
-Requires-Dist: large-image >=1.27.5.dev6
+Requires-Dist: large-image>=1.30.7.dev10
 Requires-Dist: pylibtiff
-Requires-Dist: tifftools >=1.2.0
+Requires-Dist: tifftools>=1.2.0
+Provides-Extra: all
+Requires-Dist: pylibjpeg-openjpeg; extra == "all"
 Provides-Extra: girder
-Requires-Dist: girder-large-image >=1.27.5.dev6 ; extra == 'girder'
+Requires-Dist: girder-large-image>=1.30.7.dev10; extra == "girder"
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: keywords
+Dynamic: license
+Dynamic: provides-extra
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
 
 A TIFF tilesource for large_image.
 

large_image_source_tiff-1.30.7.dev10.dist-info/RECORD

@@ -0,0 +1,10 @@
+large_image_source_tiff/__init__.py,sha256=o-NkH3SI7XLmEdejSREFMw39kfTMu2LiV3GGHsmNrPQ,36588
+large_image_source_tiff/exceptions.py,sha256=NgdwloaDCtbtUMe2BU2lXEU8IwQSYtaokIwGIFypCps,617
+large_image_source_tiff/girder_source.py,sha256=Dp2e3O4VTANYXZI_eybgzs5BcyuMcw2-MAzCUJ8zzPg,1031
+large_image_source_tiff/tiff_reader.py,sha256=gkAhuB4-IRzNLlNr958HKE9JZpRJwVo4zRGMd4rsD2o,40338
+large_image_source_tiff-1.30.7.dev10.dist-info/LICENSE,sha256=psuoW8kuDP96RQsdhzwOqi6fyWv0ct8CR6Jr7He_P_k,10173
+large_image_source_tiff-1.30.7.dev10.dist-info/METADATA,sha256=O5AbEZVfjpc5zu9f10kzVnxMz86Jqq-E18IFCQ_lvkQ,1444
+large_image_source_tiff-1.30.7.dev10.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
+large_image_source_tiff-1.30.7.dev10.dist-info/entry_points.txt,sha256=iZ43sIcj98SND7nDUC-_4qroBL6apyXN4iSbPXZ8LE4,166
+large_image_source_tiff-1.30.7.dev10.dist-info/top_level.txt,sha256=QRx_D2oeiOOz_5FlBOAoDPF-E4Q-aFmerUWlaeP14B8,24
+large_image_source_tiff-1.30.7.dev10.dist-info/RECORD,,

{large_image_source_tiff-1.27.5.dev6.dist-info → large_image_source_tiff-1.30.7.dev10.dist-info}/WHEEL

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

large_image_source_tiff-1.27.5.dev6.dist-info/RECORD

@@ -1,10 +0,0 @@
-large_image_source_tiff/__init__.py,sha256=0XCpYfa6BDT4m22xtLYO6qlxJ7vCFrWopWQQQo37FGQ,33986
-large_image_source_tiff/exceptions.py,sha256=NgdwloaDCtbtUMe2BU2lXEU8IwQSYtaokIwGIFypCps,617
-large_image_source_tiff/girder_source.py,sha256=Dp2e3O4VTANYXZI_eybgzs5BcyuMcw2-MAzCUJ8zzPg,1031
-large_image_source_tiff/tiff_reader.py,sha256=xZGz9P97LHfL5kmxVCL1ek0ry259LNp39yGls6tnpnM,38634
-large_image_source_tiff-1.27.5.dev6.dist-info/LICENSE,sha256=psuoW8kuDP96RQsdhzwOqi6fyWv0ct8CR6Jr7He_P_k,10173
-large_image_source_tiff-1.27.5.dev6.dist-info/METADATA,sha256=R2M0aEGAX6nMGr7yciHUYN2OJNqzK4r_-Uh_kylwrb4,1031
-large_image_source_tiff-1.27.5.dev6.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
-large_image_source_tiff-1.27.5.dev6.dist-info/entry_points.txt,sha256=iZ43sIcj98SND7nDUC-_4qroBL6apyXN4iSbPXZ8LE4,166
-large_image_source_tiff-1.27.5.dev6.dist-info/top_level.txt,sha256=QRx_D2oeiOOz_5FlBOAoDPF-E4Q-aFmerUWlaeP14B8,24
-large_image_source_tiff-1.27.5.dev6.dist-info/RECORD,,