Skip to main content

PyPI version

Kimimaro: Skeletonize Densely Labeled Images

# Produce SWC files from volumetric images.
kimimaro forge labels.npy --progress # writes to ./kimimaro_out/
kimimaro view kimimaro_out/10.swc

Rapidly skeletonize all non-zero labels in 2D and 3D numpy arrays using a TEASAR derived method. The returned list of skeletons is in the format used by cloud-volume. A skeleton is a stick figure 1D representation of a 2D or 3D object that consists of a graph of verticies linked by edges. A skeleton where the verticies also carry a distance to the nearest boundary they were extracted from is called a "Medial Axis Transform", which Kimimaro provides.

Skeletons are a compact representation that can be used to visualize objects, trace the connectivity of an object, or otherwise analyze the object's geometry. Kimimaro was designed for use with high resolution neurons extracted from electron microscopy data via AI segmentation, but it can be applied to many different fields.

On an Apple Silicon M1 arm64 chip (Firestorm cores 3.2 GHz max frequency), this package processed a 512x512x100 volume with 333 labels in 20 seconds. It processed a 512x512x512 volume (connectomics.npy) with 2124 labels in 187 seconds.

A Densely Labeled Volume Skeletonized with Kimimaro
Fig. 1: A Densely Labeled Volume Skeletonized with Kimimaro

pip Installation

If a binary is available for your platform:

pip install kimimaro 
# installs additional libraries to accelerate some
# operations like join_close_components
pip install "kimimaro[accel]"
# Makes the kimimaro view command work
pip install "kimimaro[view]"
# Enables TIFF generation on the CLI
pip install "kimimaro[tif]"
# Enables reading NIBABEL, NRRD, TIFF, CRACKLE on the CLI
pip install "kimimaro[all_formats]"
# Enables gpu=True and kimimaro forge --gpu via the Brook GPU backend.
# Needs Linux x86-64, Python >= 3.12, an NVIDIA GPU with compute capability
# >= 8.0 and a driver that supports CUDA 12.3+. Installs nothing on other
# platforms. Not part of "all". Also requires NumPy >= 2.4.6.
pip install "kimimaro[gpu]"
# Install all optional dependencies
pip install "kimimaro[all]"

Otherwise, you'll also need a C++ compiler:

sudo apt-get install python3-dev g++ # ubuntu linux

Example

A Densely Labeled Volume Skeletonized with Kimimaro
Fig. 2: Memory Usage on a 512x512x512 Densely Labeled Volume (`connectomics.npy`)

Figure 2 shows the memory usage and processessing time (~390 seconds, about 6.5 minutes) required when Kimimaro 1.4.0 was applied to a 512x512x512 cutout, labels, from a connectomics dataset, connectomics.npy containing 2124 connected components. The different sections of the algorithm are depicted. Grossly, the preamble runs for about half a minute, skeletonization for about six minutes, and finalization within seconds. The peak memory usage was about 4.5 GB. The code below was used to process labels. The processing of the glia was truncated in due to a combination of fix_borders and max_paths.

Kimimaro has come a long way. Version 0.2.1 took over 15 minutes and had a Preamble run time twice as long on the same dataset.

On a Macbook Pro M3, the same settings now complete in 94 seconds (1.6 minutes) on version 5.4.0. With xs3d 1.11.0, cross section analysis takes 215 seconds (3.6 minutes).

Python Interface

# LISTING 1: Producing Skeletons from a labeled image.

import kimimaro

# To obtain this 512 MB segmentation sample volume:
# pip install crackle-codec 

import crackle
labels = crackle.load("benchmarks/connectomics.npy.ckl.gz") 

skels = kimimaro.skeletonize(
  labels, 
  teasar_params={
    "scale": 1.5, 
    "const": 300, # physical units
    "pdrf_scale": 100000,
    "pdrf_exponent": 4,
    "soma_acceptance_threshold": 3500, # physical units
    "soma_detection_threshold": 750, # physical units
    "soma_invalidation_const": 300, # physical units
    "soma_invalidation_scale": 2,
    "max_paths": 300, # default None
  },
  # object_ids=[ ... ], # process only the specified labels
  # extra_targets_before=[ (27,33,100), (44,45,46) ], # target points in voxels
  # extra_targets_after=[ (27,33,100), (44,45,46) ], # target points in voxels
  dust_threshold=1000, # skip connected components with fewer than this many voxels
  anisotropy=(16,16,40), # default True
  fix_branching=True, # default True
  fix_borders=True, # default True
  fill_holes=False, # default False
  fix_avocados=False, # default False
  progress=True, # default False, show progress bar
  parallel=1, # <= 0 all cpu, 1 single process, 2+ multiprocess
  parallel_chunk_size=100, # how many skeletons to process before updating progress bar
  gpu=False, # default False, True runs on an NVIDIA GPU via Brook (see "gpu" below), ignores parallel
)

# LISTING 2: Combining skeletons produced from 
#            adjacent or overlapping images.

import kimimaro
from osteoid import Skeleton

skels = ... # a set of skeletons produced from the same label id
skel = Skeleton.simple_merge(skels).consolidate()
skel = kimimaro.postprocess(
  skel, 
  dust_threshold=1000, # physical units
  tick_threshold=3500 # physical units
)

# LISTING 3: Adding cross sectional area to skeletons
# Cross section planes are defined by normal vectors. Those
# vectors come from the difference between adjacent vertices.
skels = ... # one or more skeletons produced from a single image
skels = kimimaro.cross_sectional_area(
  labels, skels, 
  anisotropy=(16,16,40), 
  smoothing_window=5, # rolling average window of plane normals
  progress=True,
)
skel = skels[0]
skel.cross_sectional_area # array of cross sectional areas
skel.cross_sectional_area_contacts # non-zero contacted the image border

# Split input skeletons into connected components and
# then join the two nearest vertices within `radius` distance
# of each other until there is only a single connected component
# or no pairs of points nearer than `radius` exist. 
# Fuse all remaining components into a single skeleton.
skel = kimimaro.join_close_components([skel1, skel2], radius=1500) # 1500 units threshold
skel = kimimaro.join_close_components([skel1, skel2], radius=None) # no threshold

# Given synapse centroids (in voxels) and the SWC integer label you'd 
# like to assign (e.g. for pre-synaptic and post-synaptic) this finds the 
# nearest voxel to the centroid for that label.
# Input: { label: [ ((x,y,z), swc_label), ... ] }
# Returns: { (x,y,z): swc_label, ... }
extra_targets = kimimaro.synapses_to_targets(labels, synapses)


# LISTING 4: Drawing a centerline between
#   preselected points on a binary image.
#   This is a much simpler option for when
#   you know exactly what you want, but may
#   be less efficient for large scale procesing.

skel = kimimaro.connect_points(
  labels == 67301298,
  start=(3, 215, 202), 
  end=(121, 426, 227),
  anisotropy=(32,32,40),
)

# LISTING 5: Using skeletons to oversegment existing
#  segmentations for integration into proofreading systems 
#  that on merging atomic labels. oversegmented_labels 
#  is returned numbered from 1. skels is a copy returned 
#  with the property skel.segments that associates a label
#  to each vertex (labels will not be unique if downsampling 
#  is used)
oversegmented_labels, skels = kimimaro.oversegment(
  labels, skels, 
  anisotropy=(32,32,40), 
  downsample=10,
)

connectomics.npy is multilabel connectomics data derived from pinky40, a 2018 experimental automated segmentation of ~1.5 million cubic micrometers of mouse visual cortex. It is an early predecessor to the now public pinky100_v185 segmentation that can be found at https://microns-explorer.org/phase1 You will need to run lzma -d connectomics.npy.lzma to obtain the 512x512x512 uint32 volume at 32x32x40 nm3 resolution.

CLI Interface

The CLI supports producing skeletons from a single image as SWCs and viewing the resulting SWC files one at a time. By default, the SWC files are written to ./kimimaro_out/$LABEL.swc.

Here's an equivalent example to the code above.

kimimaro forge labels.npy --scale 4 --const 10 --soma-detect 1100 --soma-accept 3500 --soma-scale 1 --soma-const 300 --anisotropy 16,16,40 --fix-borders --progress 

To skeletonize on an NVIDIA GPU, add --gpu (see the gpu parameter below for the requirements and how the output differs from CPU mode). If Brook or a usable GPU is missing, the command prints an error and exits instead of falling back to the CPU.

kimimaro forge labels.npy --gpu --anisotropy 16,16,40 --progress

Visualize the your data:

kimimaro view 1241241.swc # visualize skeleton
kimimaro view labels.npy # visualize segmentation

It can also convert binary image skeletons produced by thinning algorithms into SWC files and back. This can be helpful for comparing different skeletonization algorithms or even just using their results.

kimimaro swc from binary_image.tiff # -> binary_image.swc
kimimaro swc to --format tiff binary_image.swc # -> binary_image.tiff or npy

Tweaking kimimaro.skeletonize Parameters

This algorithm works by finding a root point on a 3D object and then serially tracing paths via dijksta's shortest path algorithm through a penalty field to the most distant unvisited point. After each pass, there is a sphere (really a circumscribing cube) that expands around each vertex in the current path that marks part of the object as visited.

For a visual tutorial on the basics of the skeletonization procedure, check out this wiki article: A Pictorial Guide to TEASAR Skeletonization

For more detailed information, read below or the TEASAR paper (though we deviate from TEASAR in a few places). [1]

scale and const

Usually, the most important parameters to tweak are scale and const which control the radius of this invalidation sphere according to the equation r(x,y,z) = scale * DBF(x,y,z) + const where the dimensions are physical (e.g. nanometers, i.e. corrected for anisotropy). DBF(x,y,z) is the physical distance from the shape boundary at that point.

Check out this wiki article to help refine your intuition.

anisotropy

Represents the physical dimension of each voxel. For example, a connectomics dataset might be scanned with an electron microscope at 4nm x 4nm per pixel and stacked in slices 40nm thick. i.e. anisotropy=(4,4,40). You can use any units so long as you are consistent.

dust_threshold

This threshold culls connected components that are smaller than this many voxels.

extra_targets_after and extra_targets_before

extra_targets_after provides additional voxel targets to trace to after the morphological tracing algorithm completes. For example, you might add known synapse locations to the skeleton.

extra_targets_before is the same as extra_targets_after except that the additional targets are front-loaded and the paths that they cover are invalidated. This may affect the results of subsequent morphological tracing.

max_paths

Limits the number of paths that can be drawn for the given label. Certain cells, such as glia, that may not be important for the current analysis may be expensive to process and can be aborted early.

pdrf_scale and pdrf_exponent

The pdrf_scale and pdrf_exponent represent parameters to the penalty equation that takes the euclidean distance field (D) and augments it so that cutting closer to the border is very penalized to make dijkstra take paths that are more centered.

Pr = pdrf_scale * (1 - D / max(D)) pdrf_exponent + (directional gradient < 1.0).

The default settings should work fairly well, but under large anisotropies or with cavernous morphologies, it's possible that you might need to tweak it. If you see the skeleton go haywire inside a large area, it could be a collapse of floating point precision.

soma_acceptance_threshold and soma_detection_threshold

We process somas specially because they do not have a tubular geometry and instead should be represented in a hub and spoke manner. soma_acceptance_threshold is the physical radius (e.g. in nanometers) beyond which we classify a connected component of the image as containing a soma. The distance transform's output is depressed by holes in the label, which are frequently produced by segmentation algorithms on somata. We can fill them, but the hole filling algorithm we use is slow so we would like to only apply it occasionally. Therefore, we set a lower threshold, the soma_acceptance_threshold, beyond which we fill the holes and retest the soma.

soma_invalidation_scale and soma_invalidation_const

Once we have classified a region as a soma, we fix root of the skeletonization algorithm at one of the points of maximum distance from the boundary (usually there is only one). We then mark as visited all voxels around that point in a spherical radius described by r(x,y,z) = soma_invalidation_scale * DBF(x,y,z) + soma_invalidation_const where DBF(x,y,z) is the physical distance from the shape boundary at that point. If done correctly, this can prevent skeletons from being drawn to the boundaries of the soma, and instead pulls the skeletons mainly into the processes extending from the cell body.

fix_borders

This feature makes it easier to connect the skeletons of adjacent image volumes that do not fit in RAM. If enabled, skeletons will be deterministically drawn to the approximate center of the 2D contact area of each place where the shape contacts the border. This can affect the performance of the operation positively or negatively depending on the shape and number of contacts.

fix_branching

You'll probably never want to disable this, but base TEASAR is infamous for forking the skeleton at branch points way too early. This option makes it preferential to fork at a more reasonable place at a significant performance penalty.

fill_holes

Warning: This will remove input labels that are deemed to be holes.

If your segmentation contains artifacts that cause holes to appear in labels, you can preprocess the entire image to eliminate background holes and holes caused by entirely contained inclusions. This option adds a moderate amount of additional processing time at the beginning (perhaps ~30%).

fix_avocados

Avocados are segmentations of cell somata that classify the nucleus separately from the cytoplasm. This is a common problem in automatic segmentations due to the visual similarity of a cell membrane and a nuclear membrane combined with insufficient context.

Skeletonizing an avocado results in a poor skeletonization of the cell soma that will disconnect the nucleus and usually results in too many paths traced around the nucleus. Setting fix_avocados=True attempts to detect and fix these problems. Currently we handle non-avocados, avocados, cells with inclusions, and nested avocados. You can see examples here.

progress

Show a progress bar once the skeletonization phase begins.

parallel

Use a pool of processors to skeletonize faster. Each process allocatable task is the skeletonization of one connected component (so it won't help with a single label that takes a long time to skeletonize). This option also affects the speed of the initial euclidean distance transform, which is parallel enabled and is the most expensive part of the Preamble (described below).

parallel_chunk_size

This only applies when using parallel. This sets the number of skeletons a subprocess will extract before returning control to the main thread, updating the progress bar, and acquiring a new task. If this value is set too low (e.g. < 10-20) the cost of interprocess communication can become significant and even dominant. If it is set too high, task starvation may occur for the other subprocesses if a subprocess gets a particularly hard skeleton and they complete quickly. Progress bar updates will be infrequent if the value is too high as well.

The actual chunk size used will be min(parallel_chunk_size, len(cc_labels) // parallel). cc_labels represents the number of connected components in the sample.

gpu

skeletons = kimimaro.skeletonize(labels, anisotropy=(16,16,40), gpu=True)

Skeletonize on an NVIDIA GPU. The work is delegated to Brook, a CUDA implementation of this TEASAR variant that takes the same arguments and returns the same { segid: Skeleton } dictionary. On the 512x512x512 benchmark volume and its crops, on an RTX 4090, it was 41x to 137x faster than 32 CPU workers (3.0 s against 410 s with fix_branching on); see benchmarks/README.md. Speed depends on the shapes, the parameters and the GPU.

This requires pip install "kimimaro[gpu]" (see Installation above): Linux x86-64, Python >= 3.12, an NVIDIA GPU with compute capability >= 8.0 and a driver that supports CUDA 12.3 or newer. parallel and parallel_chunk_size are ignored (with a warning if parallel is not 1) and each call uses one GPU. For several GPUs, chunked processing of very large volumes, arrays that are already on the GPU or batches, call Brook directly (see its user guide).

gpu=True never silently falls back to the CPU. It raises an ImportError if Brook is not installed and a RuntimeError if there is no usable GPU. kimimaro.gpu.is_available() returns True or False without raising, but it initializes CUDA in the calling process (about 0.2 s and a few hundred MB of GPU memory that are held until the process exits). Call it once, and under if __name__ == "__main__": if you also use parallel, because worker processes re-import your script.

Brook streams a volume through the GPU when it estimates that the volume needs more than about half of the free GPU memory. Streaming does not support voxel_graph, fill_holes or fix_avocados, so with any of them Kimimaro runs Brook in-core and a volume that doesn't fit fails with a GPU out-of-memory RuntimeError. (kimimaro forge turns fill_holes on by default; pass --no-fill-holes to allow streaming.)

If you use GPU mode, please also cite Brook: doi:10.5281/zenodo.22947047.

Differences from CPU mode

The output is close to, but not identical to, CPU mode. Brook's user guide lists the differences it found against Kimimaro 5.8.1. The main ones:

  • Equal-cost routes. Where routes tie, Brook takes straight axial steps while Kimimaro's heap order alternates between slices. On the benchmark volume and its crops the total cable length was 0.02% to 1.3% shorter with fix_branching=False and the median per-object difference was 0.05% to 0.96% (see benchmarks/README.md); with fix_branching=True one soma dominates the totals of the larger volumes (see below). On smooth, symmetric test shapes (spheres, flat slabs, hollow shells) we measured roughly 10% to 18% shorter cable and up to 19% fewer endpoints.
  • Somas. Paths inside a soma are trimmed and re-attached to the soma root differently, so skeletons of objects with a soma can differ in connectivity and cable length. If the soma invalidation removes every voxel of an object, Kimimaro returns a one-vertex skeleton and Brook returns none.
  • Other options. fill_holes, fix_avocados, voxel_graph and unreachable targets differ in edge cases (see the user guide).
  • Brook 0.1.0. A uint64 label of 2**63 or more is returned as a negative key, and a CrackleArray is decompressed into host memory first.

Performance Tips

  • If you only need a few labels skeletonized, pass in object_ids to bypass processing all the others. If object_ids contains only a single label, the masking operation will run faster.
  • Larger TEASAR parameters scale and const require processing larger invalidation regions per path.
  • Set pdrf_exponent to a small power of two (e.g. 1, 2, 4, 8, 16) for a small speedup.
  • If you are willing to sacrifice the improved branching behavior, you can set fix_branching=False for a moderate 1.1x to 1.5x speedup (assuming your TEASAR parameters and data allow branching).
  • If your dataset contains important cells (that may in fact be the seat of consciousness) but they take significant processing power to analyze, you can save them to savor for later by setting max_paths to some reasonable level which will abort and proceed to the next label after the algorithm detects that that at least that many paths will be needed.
  • Parallel distributes work across connected components and is generally a good idea if you have the cores and memory. Not only does it make single runs proceed faster, but you can also practically use a much larger context; that improves soma processing as they are less likely to be cut off. The Preamble of the algorithm (detailed below) is still single threaded at the moment, so task latency increases with size.
  • If parallel_chunk_size is set very low (e.g. < 10) during parallel operation, interprocess communication can become a significant overhead. Try raising this value.
  • If you have a supported NVIDIA GPU and many or large volumes to skeletonize, try gpu=True (see the gpu parameter above). It ignores parallel, and its output is close to, but not identical to, CPU mode.

Motivation

The connectomics field commonly generates very large densely labeled volumes of neural tissue. Skeletons are one dimensional representations of two or three dimensional objects. They have many uses, a few of which are visualization of neurons, calculating global topological features, rapidly measuring electrical distances between objects, and imposing tree structures on neurons (useful for computation and user interfaces). There are several ways to compute skeletons and a few ways to define them [4]. After some experimentation, we found that the TEASAR [1] approach gave fairly good results. Other approaches include topological thinning ("onion peeling") and finding the centerline described by maximally inscribed spheres. Ignacio Arganda-Carreras, an alumnus of the Seung Lab, wrote a topological thinning plugin for Fiji called Skeletonize3d.

There are several implementations of TEASAR used in the connectomics field [3][5], however it is commonly understood that implementations of TEASAR are slow and can use tens of gigabytes of memory. Our goal to skeletonize all labels in a petavoxel scale image quickly showed clear that existing sparse implementations are impractical. While adapting a sparse approach to a cloud pipeline, we noticed that there are inefficiencies in repeated evaluation of the Euclidean Distance Transform (EDT), the repeated evaluation of the connected components algorithm, in the construction of the graph used by Dijkstra's algorithm where the edges are implied by the spatial relationships between voxels, in the memory cost, quadratic in the number of voxels, of representing a graph that is implicit in image, in the unnecessarily large data type used to represent relatively small cutouts, and in the repeated downloading of overlapping regions. We also found that the naive implmentation of TEASAR's "rolling invalidation ball" unnecessarily reevaluated large numbers of voxels in a way that could be loosely characterized as quadratic in the skeleton path length.

We further found that commodity implementations of the EDT supported only binary images. We were unable to find any available Python or C++ libraries for performing Dijkstra's shortest path on an image. Commodity implementations of connected components algorithms for images supported only binary images. Therefore, several libraries were devised to remedy these deficits (see Related Projects).

Why TEASAR?

TEASAR: Tree-structure Extraction Algorithm for Accurate and Robust skeletons, a 2000 paper by M. Sato and others [1], is a member of a family of algorithms that transform two and three dimensional structures into a one dimensional "skeleton" embedded in that higher dimension. One might concieve of a skeleton as extracting a stick figure drawing from a binary image. This problem is more difficult than it might seem. There are different situations one must consider when making such a drawing. For example, a stick drawing of a banana might merely be a curved centerline and a drawing of a doughnut might be a closed loop. In our case of analyzing neurons, sometimes we want the skeleton to include spines, short protrusions from dendrites that usually have synapses attached, and sometimes we want only the characterize the run length of the main trunk of a neurite.

Additionally, data quality issues can be challenging as well. If one is skeletonizing a 2D image of a doughnut, but the angle were sufficiently declinated from the ring's orthogonal axis, would it even be possible to perform this task accurately? In a 3D case, if there are breaks or mergers in the labeling of a neuron, will the algorithm function sensibly? These issues are common in both manual and automatic image sementations.

In our problem domain of skeletonizing neurons from anisotropic voxel labels, our chosen algorithm should produce tree structures, handle fine or coarse detail extraction depending on the circumstances, handle voxel anisotropy, and be reasonably efficient in CPU and memory usage. TEASAR fufills these criteria. Notably, TEASAR doesn't guarantee the centeredness of the skeleton within the shape, but it makes an effort. The basic TEASAR algorithm is known to cut corners around turns and branch too early. A 2001 paper by members of the original TEASAR team describes a method for reducing the early branching issue on page 204, section 4.2.2. [2]

TEASAR Derived Algorithm

We implemented TEASAR but made several deviations from the published algorithm in order to improve path centeredness, increase performance, handle bulging cell somas, and enable efficient chunked evaluation of large images. We opted not to implement the gradient vector field step from [2] as our implementation is already quite fast. The paper claims a reduction of 70-85% in input voxels, so it might be worth investigating.

In order to work with images that contain many labels, our general strategy is to perform as many actions as possible in such a way that all labels are treated in a single pass. Several of the component algorithms (e.g. connected components, euclidean distance transform) in our implementation can take several seconds per a pass, so it is important that they not be run hundreds or thousands of times. A large part of the engineering contribution of this package lies in the efficiency of these operations which reduce the runtime from the scale of hours to minutes.

Given a 3D labeled voxel array, I, with N >= 0 labels, and ordered triple describing voxel anisotropy A, our algorithm can be divided into three phases, the pramble, skeletonization, and finalization in that order.

I. Preamble

The Preamble takes a 3D image containing N labels and efficiently generates the connected components, distance transform, and bounding boxes needed by the skeletonization phase.

  1. To enhance performance, if N is 0 return an empty set of skeletons.
  2. Label the M connected components, Icc, of I.
  3. To save memory, renumber the connected components in order from 1 to M. Adjust the data type of the new image to the smallest uint type that will contain M and overwrite Icc.
  4. Generate a mapping of the renumbered Icc to I to assign meaningful labels to skeletons later on and delete I to save memory.
  5. Compute E, the multi-label anisotropic Euclidean Distance Transform of Icc given A. E treats all interlabel edges as transform edges, but not the boundaries of the image. Black pixels are considered background.
  6. Gather a list, Lcc of unique labels from Icc and threshold which ones to process based on the number of voxels they represent to remove "dust".
  7. In one pass, compute the list of bounding boxes, B, corresponding to each label in Lcc.

II. Skeletonization

In this phase, we extract the tree structured skeleton from each connected component label. Below, we reference variables defined in the Preamble. For clarity, we omit the soma specific processing and hold fix_branching=True.

For each label l in Lcc and B...

  1. Extract Il, the cropped binary image tightly enclosing l from Icc using Bl
  2. Using Il and Bl, extract El from E. El is the cropped tightly enclosed EDT of l. This is much faster than recomputing the EDT for each binary image.
  3. Find an arbitrary foreground voxel and using that point as a source, compute the anisotropic euclidean distance field for Il. The coordinate of the maximum value is now "the root" r.
  4. From r, compute the euclidean distance field and save it as the distance from root field Dr.
  5. Compute the penalized distance from root field Pr = pdrf_scale * ((1 - El / max(El)) ^ pdrf_exponent) + Dr / max(Dr).
  6. While Il contains foreground voxels:
    1. Identify a target coordinate, t, as the foreground voxel with maximum distance in Dr from r.
    2. Draw the shortest path p from r to t considering the voxel values in Pr as edge weights.
    3. For each vertex v in p, extend an invalidation cube of physical side length computed as scale * El(v) + const and convert any foreground pixels in Il that overlap with these cubes to background pixels.
    4. (Only if fix_branching=True) For each vertex coordinate v in p, set Pr(v) = 0.
    5. Append p to a list of paths for this label.
  7. Using El, extract the distance to the nearest boundary each vertex in the skeleton represents.
  8. For each raw skeleton extracted from Il, translate the vertices by Bl to correct for the translation the cropping operation induced.
  9. Multiply the vertices by the anisotropy A to place them in physical space.

If soma processing is considered, we modify the root (r) search process as follows:

  1. If max(El) > soma_detection_threshold...
  2. Fill toplogical holes in Il. Soma are large regions that often have dust from imperfect automatic labeling methods.
  3. Recompute El from this cleaned up image.
  4. If max(El) > soma_acceptance_threshold, divert to soma processing mode.
  5. If in soma processing mode, continue, else go to step 3 in the algorithm above.
  6. Set r to the coordinate corresponding to max(El)
  7. Create an invalidation sphere of physical radius soma_invalidation_scale * max(El) + soma_invalidation_const and erase foreground voxels from Il contained within it. This helps prevent errant paths from being drawn all over the soma.
  8. Continue from step 4 in the above algorithm.

III. Finalization

In the final phase, we agglomerate the disparate connected component skeletons into single skeletons and assign their labels corresponding to the input image. This step is artificially broken out compared to how intermingled its implementation is with skeletonization, but it's conceptually separate.

Deviations from TEASAR

There were several places where we took a different approach than called for by the TEASAR authors.

Using DAF for Targets, PDRF for Pathfinding

The original TEASAR algorithm defines the Penalized Distance from Root voxel Field (PDRF, Pr above) as:

PDRF = 5000 * (1 - DBF / max(DBF))^16 + DAF

DBF is the Distance from Boundary Field (El above) and DAF is the Distance from Any voxel Field (Dr above).

We found the addition of the DAF tended to perturb the skeleton path from the centerline better described by the inverted DBF alone. We also found it helpful to modify the constant and exponent to tune cornering behavior. Initially, we completely stripped out the addition of the DAF from the PDRF, but this introduced a different kind of problem. The exponentiation of the PDRF caused floating point values to collapse in wide open spaces. This made the skeletons go crazy as they traced out a path described by floating point errors.

The DAF provides a very helpful gradient to follow between the root and the target voxel, we just don't want that gradient to knock the path off the centerline. Therefore, in light of the fact that the PDRF base field is very large, we add the normalized DAF which is just enough to overwhelm floating point errors and provide direction in wide tubes and bulges.

The original paper also called for selecting targets using the max(PDRF) foreground values. However, this is a bit strange since the PDRF values are dominated by boundary effects rather than a pure distance metric. Therefore, we select targets from the max(DAF) forground value.

Zero Weighting Previous Paths (fix_branching=True)

The 2001 skeletonization paper [2] called for correcting early forking by computing a DAF using already computed path vertices as field sources. This allows Dijkstra's algorithm to trace the existing path cost free and diverge from it at a closer point to the target.

As we have strongly deemphasized the role of the DAF in dijkstra path finding, computing this field is unnecessary and we only need to set the PDRF to zero along the path of existing skeletons to achieve this effect. This saves us an expensive repeated DAF calculation per path.

However, we still incur a substantial cost for taking this approach because we had been computing a dijkstra "parental field" that recorded the shortest path to the root from every foreground voxel. We then used this saved result to rapidly compute all paths. However, as this zero weighting modification makes successive calculations dependent upon previous ones, we need to compute Dijkstra's algorithm anew for each path.

Non-Overlapped Chunked Processing (fix_borders=True)

When processing large volumes, a sensible approach for mass producing skeletons is to chunk the volume, process the chunks independently, and merge the resulting skeleton fragments at the end. However, this is complicated by the "edge effect" induced by a loss of context which makes it impossible to expect the endpoints of skeleton fragments produced by adjacent chunks to align. In contrast, it is easy to join mesh fragments because the vertices of the edge of mesh fragments lie at predictable identical locations given one pixel of overlap.

Previously, we had used 50% overlap to join adjacent skeleton fragments which increased the compute cost of skeletonizing a large volume by eight times. However, if we could force skeletons to lie at predictable locations on the border, we could use single pixel overlap and copy the simple mesh joining approach. As an (incorrect but useful) intuition for how one might go about this, consider computing the centroid of each connected component on each border plane and adding that as a required path target. This would guarantee that both sides of the plane connect at the same pixel. However, the centroid may not lie inside of non-convex hulls so we have to be more sophisticated and select some real point inside of the shape.

To this end, we again repurpose the euclidean distance transform and apply it to each of the six planes of connected components and select the maximum value as a mandatory target. This works well for many types of objects that contact a single plane and have a single maximum. However, we must treat the corners of the box and shapes that have multiple maxima.

To handle shapes that contact multiple sides of the box, we simply assign targets to all connected components. If this introduces a cycle in post-processing, we already have cycle removing code to handle it in Igneous. If it introduces tiny useless appendages, we also have code to handle this.

If a shape has multiple distance transform maxima, it is important to choose the same pixel without needing to communicate between spatially adjacent tasks which may run at different times on different machines. Additionally, the same plane on adjacent tasks has the coordinate system flipped. One simple approach might be to pick the coordinate with minimum x and y (or some other coordinate based criterion) in one of the coordinate frames, but this requires tracking the flips on all six planes and is annoying. Instead, we use a series of coordinate-free topology based filters which is both more fun, effort efficient, and picks something reasonable looking. A valid criticism of this approach is that it will fail on a perfectly symmetrical object, but these objects are rare in biological data.

We apply a series of filters and pick the point based on the first filter it passes:

  1. The voxel closest to the centroid of the current label.
  2. The voxel closest to the centroid of the image plane.
  3. Closest to a corner of the plane.
  4. Closest to an edge of the plane.
  5. The previously found maxima.

It is important that filter #1 be based on the shape of the label so that kinks are minimimized for convex hulls. For example, originally we used only filters two thru five, but this caused skeletons for neurites located away from the center of a chunk to suddenly jink towards the center of the chunk at chunk boundaries.

Several classic algorithms had to be specially tuned to make this module possible.

  1. edt: A single pass, multi-label anisotropy supporting euclidean distance transform implementation.
  2. dijkstra3d: Dijkstra's shortest-path algorithm defined on 26-connected 3D images. This avoids the time cost of edge generation and wasted memory of a graph representation.
  3. connected-components-3d: A connected components implementation defined on 26-connected 3D images with multiple labels.
  4. fastremap: Allows high speed renumbering of labels from 1 in a 3D array in order to reduce memory consumption caused by unnecessarily large 32 and 64-bit labels.
  5. fill_voids: High speed binary_fill_holes.
  6. xs3d: Cross section analysis of 3D images.

This module was originally designed to be used with CloudVolume and Igneous.

  1. CloudVolume: Serverless client for reading and writing petascale chunked images of neural tissue, meshes, and skeletons.
  2. Igneous: Distributed computation for visualizing connectomics datasets.

Some of the TEASAR modifications used in this package were first demonstrated by Alex Bae.

  1. skeletonization: Python implementation of modified TEASAR for sparse labels.

Credits

Alex Bae developed the precursor skeletonization package and several modifications to TEASAR that we use in this package. Alex also developed the postprocessing approach used for stitching skeletons using 50% overlap. Will Silversmith adapted these techniques for mass production, refined several basic algorithms for handling thousands of labels at once, and rewrote them into the Kimimaro package. Will added trickle DAF, zero weighted previously explored paths, and fixing borders to the algorithm. A.M. Wilson and Will designed the nucleus/soma "avocado" fuser. Forrest Collman added parameter flexibility and helped tune DAF computation performance. Sven Dorkenwald and Forrest both provided helpful discussions and feedback. Peter Li redesigned the target selection algorithm to avoid bilinear performance on complex cells.

Acknowledgments

We are grateful to our partners in the Seung Lab, the Allen Institute for Brain Science, and the Baylor College of Medicine for providing the data and problems necessitating this library.

This research was supported by the Intelligence Advanced Research Projects Activity (IARPA) via Department of Interior/ Interior Business Center (DoI/IBC) contract number D16PC0005, NIH/NIMH (U01MH114824, U01MH117072, RF1MH117815), NIH/NINDS (U19NS104648, R01NS104926), NIH/NEI (R01EY027036), and ARO (W911NF-12-1-0594). The U.S. Government is authorized to reproduce and distribute reprints for Governmental purposes notwithstanding any copyright annotation thereon. Disclaimer: The views and conclusions contained herein are those of the authors and should not be interpreted as necessarily representing the official policies or endorsements, either expressed or implied, of IARPA, DoI/IBC, or the U.S. Government. We are grateful for assistance from Google, Amazon, and Intel.

Papers Using Kimimaro

Please cite Kimimaro using the CITATION.cff file located in this repository.

The below list is not comprehensive and is sourced from collaborators or found using internet searches and does not constitute an endorsement except to the extent that they used it for their work.

  1. A.M. Wilson, R. Schalek, A. Suissa-Peleg, T.R. Jones, S. Knowles-Barley, H. Pfister, J.M. Lichtman. "Developmental Rewiring between Cerebellar Climbing Fibers and Purkinje Cells Begins with Positive Feedback Synapse Addition". Cell Reports. Vol. 29, Iss. 9, November 2019. Pgs. 2849-2861.e6 doi: 10.1016/j.celrep.2019.10.081 (link)
  2. S. Dorkenwald, N.L. Turner, T. Macrina, K. Lee, R. Lu, J. Wu, A.L. Bodor, A.A. Bleckert, D. Brittain, N. Kemnitz, W.M. Silversmith, D. Ih, J. Zung, A. Zlateski, I. Tartavull, S. Yu, S. Popovych, W. Wong, M. Castro, C. S. Jordan, A.M. Wilson, E. Froudarakis, J. Buchanan, M. Takeno, R. Torres, G. Mahalingam, F. Collman, C. Schneider-Mizell, D.J. Bumbarger, Y. Li, L. Becker, S. Suckow, J. Reimer, A.S. Tolias, N. Maçarico da Costa, R. C. Reid, H.S. Seung. "Binary and analog variation of synapses between cortical pyramidal neurons". bioRXiv. December 2019. doi: 10.1101/2019.12.29.890319 (link)
  3. N.L. Turner, T. Macrina, J.A. Bae, R. Yang, A.M. Wilson, C. Schneider-Mizell, K. Lee, R. Lu, J. Wu, A.L. Bodor, A.A. Bleckert, D. Brittain, E. Froudarakis, S. Dorkenwald, F. Collman, N. Kemnitz, D. Ih, W.M. Silversmith, J. Zung, A. Zlateski, I. Tartavull, S. Yu, S. Popovych, S. Mu, W. Wong, C.S. Jordan, M. Castro, J. Buchanan, D.J. Bumbarger, M. Takeno, R. Torres, G. Mahalingam, L. Elabbady, Y. Li, E. Cobos, P. Zhou, S. Suckow, L. Becker, L. Paninski, F. Polleux, J. Reimer, A.S. Tolias, R.C. Reid, N. Maçarico da Costa, H.S. Seung. "Multiscale and multimodal reconstruction of cortical structure and function". bioRxiv. October 2020; doi: 10.1101/2020.10.14.338681 (link)
  4. P.H. Li, L.F. Lindsey, M. Januszewski, Z. Zheng, A.S. Bates, I. Taisz, M. Tyka, M. Nichols, F. Li, E. Perlman, J. Maitin-Shepard, T. Blakely, L. Leavitt, G. S.X.E. Jefferis, D. Bock, V. Jain. "Automated Reconstruction of a Serial-Section EM Drosophila Brain with Flood-Filling Networks and Local Realignment". bioRxiv. October 2020. doi: 10.1101/605634 (link)

References

  1. M. Sato, I. Bitter, M.A. Bender, A.E. Kaufman, and M. Nakajima. "TEASAR: Tree-structure Extraction Algorithm for Accurate and Robust Skeletons". Proc. 8th Pacific Conf. on Computer Graphics and Applications. Oct. 2000. doi: 10.1109/PCCGA.2000.883951 (link)
  2. I. Bitter, A.E. Kaufman, and M. Sato. "Penalized-distance volumetric skeleton algorithm". IEEE Transactions on Visualization and Computer Graphics Vol. 7, Iss. 3, Jul-Sep 2001. doi: 10.1109/2945.942688 (link)
  3. T. Zhao, S. Plaza. "Automatic Neuron Type Identification by Neurite Localization in the Drosophila Medulla". Sept. 2014. arXiv:1409.1892 [q-bio.NC] (link)
  4. A. Tagliasacchi, T. Delame, M. Spagnuolo, N. Amenta, A. Telea. "3D Skeletons: A State-of-the-Art Report". May 2016. Computer Graphics Forum. Vol. 35, Iss. 2. doi: 10.1111/cgf.12865 (link)
  5. P. Li, L. Lindsey, M. Januszewski, Z. Zheng, A. Bates, I. Taisz, M. Tyka, M. Nichols, F. Li, E. Perlman, J. Maitin-Shepard, T. Blakely, L. Leavitt, G. Jefferis, D. Bock, V. Jain. "Automated Reconstruction of a Serial-Section EM Drosophila Brain with Flood-Filling Networks and Local Realignment". April 2019. bioRXiv. doi: 10.1101/605634 (link)
  6. M.M. McKerns, L. Strand, T. Sullivan, A. Fang, M.A.G. Aivazis, "Building a framework for predictive science", Proceedings of the 10th Python in Science Conference, 2011; http://arxiv.org/pdf/1202.1056
  7. Michael McKerns and Michael Aivazis, "pathos: a framework for heterogeneous computing", 2010- ; http://trac.mystic.cacr.caltech.edu/project/pathos

Metadata

Release files for kimimaro 5.9.0

For a detailed explanation of source distributions (sdists) and built distributions (wheels), please see the package formats documentation.

Source distribution (sdist)

Source distribution for kimimaro 5.9.0
File Size Uploaded Provenance Actions
kimimaro-5.9.0.tar.gz 563.5 kB Without provenance Details for kimimaro-5.9.0.tar.gz

Built distributions (wheels)

Table of built distributions (wheels) for kimimaro 5.9.0
File Actions
kimimaro-5.9.0-cp314-cp314t-win_amd64.whl CPython 3.14 CPython 3.14 free-threading Windows x86-64 Details for kimimaro-5.9.0-cp314-cp314t-win_amd64.whl
kimimaro-5.9.0-cp314-cp314t-win32.whl CPython 3.14 CPython 3.14 free-threading Windows x86-32 Details for kimimaro-5.9.0-cp314-cp314t-win32.whl
kimimaro-5.9.0-cp314-cp314t-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl CPython 3.14 CPython 3.14 free-threading Linux glibc 2.28+ x86-64, Linux glibc 2.24+ x86-64 Details for kimimaro-5.9.0-cp314-cp314t-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl
kimimaro-5.9.0-cp314-cp314t-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl CPython 3.14 CPython 3.14 free-threading Linux glibc 2.28+ ARM64, Linux glibc 2.24+ ARM64 Details for kimimaro-5.9.0-cp314-cp314t-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl
kimimaro-5.9.0-cp314-cp314t-macosx_11_0_arm64.whl CPython 3.14 CPython 3.14 free-threading macOS 11.0+ ARM64 Details for kimimaro-5.9.0-cp314-cp314t-macosx_11_0_arm64.whl
kimimaro-5.9.0-cp314-cp314t-macosx_10_13_x86_64.whl CPython 3.14 CPython 3.14 free-threading macOS 10.13+ x86-64 Details for kimimaro-5.9.0-cp314-cp314t-macosx_10_13_x86_64.whl
kimimaro-5.9.0-cp314-cp314-win_amd64.whl CPython 3.14 CPython 3.14 Windows x86-64 Details for kimimaro-5.9.0-cp314-cp314-win_amd64.whl
kimimaro-5.9.0-cp314-cp314-win32.whl CPython 3.14 CPython 3.14 Windows x86-32 Details for kimimaro-5.9.0-cp314-cp314-win32.whl
kimimaro-5.9.0-cp314-cp314-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl CPython 3.14 CPython 3.14 Linux glibc 2.28+ x86-64, Linux glibc 2.24+ x86-64 Details for kimimaro-5.9.0-cp314-cp314-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl
kimimaro-5.9.0-cp314-cp314-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl CPython 3.14 CPython 3.14 Linux glibc 2.24+ ARM64, Linux glibc 2.28+ ARM64 Details for kimimaro-5.9.0-cp314-cp314-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl
kimimaro-5.9.0-cp314-cp314-macosx_11_0_arm64.whl CPython 3.14 CPython 3.14 macOS 11.0+ ARM64 Details for kimimaro-5.9.0-cp314-cp314-macosx_11_0_arm64.whl
kimimaro-5.9.0-cp314-cp314-macosx_10_13_x86_64.whl CPython 3.14 CPython 3.14 macOS 10.13+ x86-64 Details for kimimaro-5.9.0-cp314-cp314-macosx_10_13_x86_64.whl
kimimaro-5.9.0-cp313-cp313-win_amd64.whl CPython 3.13 CPython 3.13 Windows x86-64 Details for kimimaro-5.9.0-cp313-cp313-win_amd64.whl
kimimaro-5.9.0-cp313-cp313-win32.whl CPython 3.13 CPython 3.13 Windows x86-32 Details for kimimaro-5.9.0-cp313-cp313-win32.whl
kimimaro-5.9.0-cp313-cp313-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl CPython 3.13 CPython 3.13 Linux glibc 2.28+ x86-64, Linux glibc 2.24+ x86-64 Details for kimimaro-5.9.0-cp313-cp313-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl
kimimaro-5.9.0-cp313-cp313-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl CPython 3.13 CPython 3.13 Linux glibc 2.28+ ARM64, Linux glibc 2.24+ ARM64 Details for kimimaro-5.9.0-cp313-cp313-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl
kimimaro-5.9.0-cp313-cp313-macosx_11_0_arm64.whl CPython 3.13 CPython 3.13 macOS 11.0+ ARM64 Details for kimimaro-5.9.0-cp313-cp313-macosx_11_0_arm64.whl
kimimaro-5.9.0-cp313-cp313-macosx_10_13_x86_64.whl CPython 3.13 CPython 3.13 macOS 10.13+ x86-64 Details for kimimaro-5.9.0-cp313-cp313-macosx_10_13_x86_64.whl
kimimaro-5.9.0-cp312-cp312-win_amd64.whl CPython 3.12 CPython 3.12 Windows x86-64 Details for kimimaro-5.9.0-cp312-cp312-win_amd64.whl
kimimaro-5.9.0-cp312-cp312-win32.whl CPython 3.12 CPython 3.12 Windows x86-32 Details for kimimaro-5.9.0-cp312-cp312-win32.whl
kimimaro-5.9.0-cp312-cp312-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl CPython 3.12 CPython 3.12 Linux glibc 2.24+ x86-64, Linux glibc 2.28+ x86-64 Details for kimimaro-5.9.0-cp312-cp312-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl
kimimaro-5.9.0-cp312-cp312-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl CPython 3.12 CPython 3.12 Linux glibc 2.28+ ARM64, Linux glibc 2.24+ ARM64 Details for kimimaro-5.9.0-cp312-cp312-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl
kimimaro-5.9.0-cp312-cp312-macosx_11_0_arm64.whl CPython 3.12 CPython 3.12 macOS 11.0+ ARM64 Details for kimimaro-5.9.0-cp312-cp312-macosx_11_0_arm64.whl
kimimaro-5.9.0-cp312-cp312-macosx_10_13_x86_64.whl CPython 3.12 CPython 3.12 macOS 10.13+ x86-64 Details for kimimaro-5.9.0-cp312-cp312-macosx_10_13_x86_64.whl
kimimaro-5.9.0-cp311-cp311-win_amd64.whl CPython 3.11 CPython 3.11 Windows x86-64 Details for kimimaro-5.9.0-cp311-cp311-win_amd64.whl
kimimaro-5.9.0-cp311-cp311-win32.whl CPython 3.11 CPython 3.11 Windows x86-32 Details for kimimaro-5.9.0-cp311-cp311-win32.whl
kimimaro-5.9.0-cp311-cp311-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl CPython 3.11 CPython 3.11 Linux glibc 2.28+ x86-64, Linux glibc 2.24+ x86-64 Details for kimimaro-5.9.0-cp311-cp311-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl
kimimaro-5.9.0-cp311-cp311-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl CPython 3.11 CPython 3.11 Linux glibc 2.24+ ARM64, Linux glibc 2.28+ ARM64 Details for kimimaro-5.9.0-cp311-cp311-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl
kimimaro-5.9.0-cp311-cp311-macosx_11_0_arm64.whl CPython 3.11 CPython 3.11 macOS 11.0+ ARM64 Details for kimimaro-5.9.0-cp311-cp311-macosx_11_0_arm64.whl
kimimaro-5.9.0-cp311-cp311-macosx_10_9_x86_64.whl CPython 3.11 CPython 3.11 macOS 10.9+ x86-64 Details for kimimaro-5.9.0-cp311-cp311-macosx_10_9_x86_64.whl
kimimaro-5.9.0-cp310-cp310-win_amd64.whl CPython 3.10 CPython 3.10 Windows x86-64 Details for kimimaro-5.9.0-cp310-cp310-win_amd64.whl
kimimaro-5.9.0-cp310-cp310-win32.whl CPython 3.10 CPython 3.10 Windows x86-32 Details for kimimaro-5.9.0-cp310-cp310-win32.whl
kimimaro-5.9.0-cp310-cp310-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl CPython 3.10 CPython 3.10 Linux glibc 2.24+ x86-64, Linux glibc 2.28+ x86-64 Details for kimimaro-5.9.0-cp310-cp310-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl
kimimaro-5.9.0-cp310-cp310-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl CPython 3.10 CPython 3.10 Linux glibc 2.28+ ARM64, Linux glibc 2.24+ ARM64 Details for kimimaro-5.9.0-cp310-cp310-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl
kimimaro-5.9.0-cp310-cp310-macosx_11_0_arm64.whl CPython 3.10 CPython 3.10 macOS 11.0+ ARM64 Details for kimimaro-5.9.0-cp310-cp310-macosx_11_0_arm64.whl
kimimaro-5.9.0-cp310-cp310-macosx_10_9_x86_64.whl CPython 3.10 CPython 3.10 macOS 10.9+ x86-64 Details for kimimaro-5.9.0-cp310-cp310-macosx_10_9_x86_64.whl
kimimaro-5.9.0-cp39-cp39-win_amd64.whl CPython 3.9 CPython 3.9 Windows x86-64 Details for kimimaro-5.9.0-cp39-cp39-win_amd64.whl
kimimaro-5.9.0-cp39-cp39-win32.whl CPython 3.9 CPython 3.9 Windows x86-32 Details for kimimaro-5.9.0-cp39-cp39-win32.whl
kimimaro-5.9.0-cp39-cp39-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl CPython 3.9 CPython 3.9 Linux glibc 2.24+ x86-64, Linux glibc 2.28+ x86-64 Details for kimimaro-5.9.0-cp39-cp39-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl
kimimaro-5.9.0-cp39-cp39-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl CPython 3.9 CPython 3.9 Linux glibc 2.28+ ARM64, Linux glibc 2.24+ ARM64 Details for kimimaro-5.9.0-cp39-cp39-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl
kimimaro-5.9.0-cp39-cp39-macosx_11_0_arm64.whl CPython 3.9 CPython 3.9 macOS 11.0+ ARM64 Details for kimimaro-5.9.0-cp39-cp39-macosx_11_0_arm64.whl
kimimaro-5.9.0-cp39-cp39-macosx_10_9_x86_64.whl CPython 3.9 CPython 3.9 macOS 10.9+ x86-64 Details for kimimaro-5.9.0-cp39-cp39-macosx_10_9_x86_64.whl

Total release size: 49.2 MB

Release files / kimimaro-5.9.0.tar.gz

Download URL kimimaro-5.9.0.tar.gz
Size 563.5 kB
Tags Source
SHA-256 checksum
How to use checksums
f9263f7a7497db625447873d05d8cc311044d7f88eb907cb51186a086d3d99fc
BLAKE2b-256 checksum
How to use checksums
55794e0bcb07e65aadcfcfd8dad7c613d65627826ff547f3ed3b337520c55dba
Upload date
Uploaded using Trusted Publishing?
What is trusted publishing?
No
Uploaded via twine/6.1.0 CPython/3.11.3

Release files / kimimaro-5.9.0-cp314-cp314t-win_amd64.whl

Download URL kimimaro-5.9.0-cp314-cp314t-win_amd64.whl
Size 337.7 kB
Tags CPython 3.14 CPython 3.14 free-threading Windows x86-64
SHA-256 checksum
How to use checksums
8ee9667e8e6321515e5984dd4639acd3c9539302d307e74492976a2fbe336555
BLAKE2b-256 checksum
How to use checksums
d334f8ef37c5ea37769f9c67f90743d73cd7d4a281ea12853bf18e5daf57ea52
Upload date
Uploaded using Trusted Publishing?
What is trusted publishing?
No
Uploaded via twine/6.1.0 CPython/3.11.3

Release files / kimimaro-5.9.0-cp314-cp314t-win32.whl

Download URL kimimaro-5.9.0-cp314-cp314t-win32.whl
Size 289.6 kB
Tags CPython 3.14 CPython 3.14 free-threading Windows x86-32
SHA-256 checksum
How to use checksums
14d6bc820f9f2fd845481521cda9f4420b6c38155efbe7d85acd73c698405cb9
BLAKE2b-256 checksum
How to use checksums
b065a2b42de1b251850c68a159fd075b80befe2d68ad46c43aca740817864fc7
Upload date
Uploaded using Trusted Publishing?
What is trusted publishing?
No
Uploaded via twine/6.1.0 CPython/3.11.3

Release files / kimimaro-5.9.0-cp314-cp314t-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl

Download URL kimimaro-5.9.0-cp314-cp314t-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl
Size 2.8 MB
Tags CPython 3.14 CPython 3.14 free-threading Linux glibc 2.24+ x86-64 Linux glibc 2.28+ x86-64
SHA-256 checksum
How to use checksums
c63af41de9970875fb2b665c242992287374546a989336f52216d5d05ad3a2fb
BLAKE2b-256 checksum
How to use checksums
33169b57a89e3196c41755fcf62cdc35db4d815986f079bc51a4597704a6a6cf
Upload date
Uploaded using Trusted Publishing?
What is trusted publishing?
No
Uploaded via twine/6.1.0 CPython/3.11.3

Release files / kimimaro-5.9.0-cp314-cp314t-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl

Download URL kimimaro-5.9.0-cp314-cp314t-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl
Size 2.8 MB
Tags CPython 3.14 CPython 3.14 free-threading Linux glibc 2.24+ ARM64 Linux glibc 2.28+ ARM64
SHA-256 checksum
How to use checksums
58fc9b7322f7633e5a8172fc5db8d30d401ba0b1b770c6e23f2330054ef95d71
BLAKE2b-256 checksum
How to use checksums
28a3a97ef33627f93f4f44e2dfa3c47f5c67905c1306d0a1c3adea108d74ff21
Upload date
Uploaded using Trusted Publishing?
What is trusted publishing?
No
Uploaded via twine/6.1.0 CPython/3.11.3

Release files / kimimaro-5.9.0-cp314-cp314t-macosx_11_0_arm64.whl

Download URL kimimaro-5.9.0-cp314-cp314t-macosx_11_0_arm64.whl
Size 362.4 kB
Tags CPython 3.14 CPython 3.14 free-threading macOS 11.0+ ARM64
SHA-256 checksum
How to use checksums
302ea06fcfc55fbad8a5a41e2b1f1a589d665ae84ca6eb154352dfd8bddb8966
BLAKE2b-256 checksum
How to use checksums
ded4c2f1657a37c6cc360be23d00dad662e4e09988109dae9aa3cdc293fdbb3b
Upload date
Uploaded using Trusted Publishing?
What is trusted publishing?
No
Uploaded via twine/6.1.0 CPython/3.11.3

Release files / kimimaro-5.9.0-cp314-cp314t-macosx_10_13_x86_64.whl

Download URL kimimaro-5.9.0-cp314-cp314t-macosx_10_13_x86_64.whl
Size 385.8 kB
Tags CPython 3.14 CPython 3.14 free-threading macOS 10.13+ x86-64
SHA-256 checksum
How to use checksums
6060dea1c652f98838267897eb170ee4b2f9fa3737048985fc511a9d2f5ddeec
BLAKE2b-256 checksum
How to use checksums
09abe132570d39ef62dc90d41cd089d37cdecf1645541cf2bb470d2530605de4
Upload date
Uploaded using Trusted Publishing?
What is trusted publishing?
No
Uploaded via twine/6.1.0 CPython/3.11.3

Release files / kimimaro-5.9.0-cp314-cp314-win_amd64.whl

Download URL kimimaro-5.9.0-cp314-cp314-win_amd64.whl
Size 314.7 kB
Tags CPython 3.14 Windows x86-64
SHA-256 checksum
How to use checksums
3e3b6dd333fa7066028ed286f4f389bcbdd3f8fdb4a80fc15a36be7ec12fe6bf
BLAKE2b-256 checksum
How to use checksums
83c4f7119247f67fc1ba6ae260009f3d405300fac8eeb8e861fbdf0e377d12af
Upload date
Uploaded using Trusted Publishing?
What is trusted publishing?
No
Uploaded via twine/6.1.0 CPython/3.11.3

Release files / kimimaro-5.9.0-cp314-cp314-win32.whl

Download URL kimimaro-5.9.0-cp314-cp314-win32.whl
Size 270.9 kB
Tags CPython 3.14 Windows x86-32
SHA-256 checksum
How to use checksums
92ca80e7a6a24205c531f97c2980e6a4cdfc7bf02b1ee0a70ebb03900f97c702
BLAKE2b-256 checksum
How to use checksums
7672ae06b886d5a11407e671dff4a3df7af4f4cbfc087ad5c7457c6ccaa7d285
Upload date
Uploaded using Trusted Publishing?
What is trusted publishing?
No
Uploaded via twine/6.1.0 CPython/3.11.3

Release files / kimimaro-5.9.0-cp314-cp314-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl

Download URL kimimaro-5.9.0-cp314-cp314-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl
Size 2.9 MB
Tags CPython 3.14 Linux glibc 2.24+ x86-64 Linux glibc 2.28+ x86-64
SHA-256 checksum
How to use checksums
a7efe53b2df12a409d02a0371e3918fb00abe4fb0b3d93730b9aee8f8bc765a4
BLAKE2b-256 checksum
How to use checksums
618ab4e7cf3f016ee3836605609b8ecbeb24d768956fac9e48e14aadbef0a314
Upload date
Uploaded using Trusted Publishing?
What is trusted publishing?
No
Uploaded via twine/6.1.0 CPython/3.11.3

Release files / kimimaro-5.9.0-cp314-cp314-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl

Download URL kimimaro-5.9.0-cp314-cp314-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl
Size 2.8 MB
Tags CPython 3.14 Linux glibc 2.24+ ARM64 Linux glibc 2.28+ ARM64
SHA-256 checksum
How to use checksums
17176a61fa725cd7821fcb42710e6270344ca498f548773d09d4f683849754f6
BLAKE2b-256 checksum
How to use checksums
994d18d5a1e7ba212d62f33c44f4f4dc8a99f81f45445ea40d37649611f7d8b0
Upload date
Uploaded using Trusted Publishing?
What is trusted publishing?
No
Uploaded via twine/6.1.0 CPython/3.11.3

Release files / kimimaro-5.9.0-cp314-cp314-macosx_11_0_arm64.whl

Download URL kimimaro-5.9.0-cp314-cp314-macosx_11_0_arm64.whl
Size 340.9 kB
Tags CPython 3.14 macOS 11.0+ ARM64
SHA-256 checksum
How to use checksums
a4c84cb615328c731a9bc8540d85ea1b0ab50f720f0b9af6d3f95216c051b9b9
BLAKE2b-256 checksum
How to use checksums
01b56fc9bc92d52f0751f26836d869dfa6743b3739ce587eb253dea331f72761
Upload date
Uploaded using Trusted Publishing?
What is trusted publishing?
No
Uploaded via twine/6.1.0 CPython/3.11.3

Release files / kimimaro-5.9.0-cp314-cp314-macosx_10_13_x86_64.whl

Download URL kimimaro-5.9.0-cp314-cp314-macosx_10_13_x86_64.whl
Size 366.0 kB
Tags CPython 3.14 macOS 10.13+ x86-64
SHA-256 checksum
How to use checksums
7f60eaa08f6c83d9aa2d315d031382b505f92a7a4faddcfaf0ffe2e1f396be34
BLAKE2b-256 checksum
How to use checksums
75ffda064b156f8ab707edd4795306b6545da6d2244e161ab4191d604a8cc183
Upload date
Uploaded using Trusted Publishing?
What is trusted publishing?
No
Uploaded via twine/6.1.0 CPython/3.11.3

Release files / kimimaro-5.9.0-cp313-cp313-win_amd64.whl

Download URL kimimaro-5.9.0-cp313-cp313-win_amd64.whl
Size 307.9 kB
Tags CPython 3.13 Windows x86-64
SHA-256 checksum
How to use checksums
fab1b740bfa0f26f5a3f85162b18d944cb9196b635b250d1ab77e4930c5acdce
BLAKE2b-256 checksum
How to use checksums
b812161662c3aaf2375303710cc4fd1ce96acb10213ade13577c0c8734df6c6b
Upload date
Uploaded using Trusted Publishing?
What is trusted publishing?
No
Uploaded via twine/6.1.0 CPython/3.11.3

Release files / kimimaro-5.9.0-cp313-cp313-win32.whl

Download URL kimimaro-5.9.0-cp313-cp313-win32.whl
Size 265.4 kB
Tags CPython 3.13 Windows x86-32
SHA-256 checksum
How to use checksums
4e2a7423987bf3dee8637a788a3342987b74cd4dcc71700c93b769b31c043601
BLAKE2b-256 checksum
How to use checksums
dc25daa6789afb4ae2e2f4326b77b9581bf9334b09982c12ea48ec87f6b631bf
Upload date
Uploaded using Trusted Publishing?
What is trusted publishing?
No
Uploaded via twine/6.1.0 CPython/3.11.3

Release files / kimimaro-5.9.0-cp313-cp313-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl

Download URL kimimaro-5.9.0-cp313-cp313-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl
Size 2.9 MB
Tags CPython 3.13 Linux glibc 2.24+ x86-64 Linux glibc 2.28+ x86-64
SHA-256 checksum
How to use checksums
0a0f3c1ee0004a579de6db80bccf11e45b4f8fe07e5530ba0fdc021a040c7e59
BLAKE2b-256 checksum
How to use checksums
b77e77648df9a14342e190a3b9f4efed1bcacadef50ff96a5a7a3419d771ed4c
Upload date
Uploaded using Trusted Publishing?
What is trusted publishing?
No
Uploaded via twine/6.1.0 CPython/3.11.3

Release files / kimimaro-5.9.0-cp313-cp313-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl

Download URL kimimaro-5.9.0-cp313-cp313-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl
Size 2.8 MB
Tags CPython 3.13 Linux glibc 2.24+ ARM64 Linux glibc 2.28+ ARM64
SHA-256 checksum
How to use checksums
99316bd8dd0b803825cddf658b3cb9921ad34fa978697c305b54edb60b5648bd
BLAKE2b-256 checksum
How to use checksums
ebe73d4318e4aef0bacfec613e3c9ea73c002e2886113029bd656125a3166301
Upload date
Uploaded using Trusted Publishing?
What is trusted publishing?
No
Uploaded via twine/6.1.0 CPython/3.11.3

Release files / kimimaro-5.9.0-cp313-cp313-macosx_11_0_arm64.whl

Download URL kimimaro-5.9.0-cp313-cp313-macosx_11_0_arm64.whl
Size 338.6 kB
Tags CPython 3.13 macOS 11.0+ ARM64
SHA-256 checksum
How to use checksums
2d2b3733199bc45b62b42f05b461bb6f20fe80575c49e70567b5bf5ab1b6b5d8
BLAKE2b-256 checksum
How to use checksums
25ed232b15482070ce037258f464b2142a8133f1e23e1a9ab916d78efffa0d72
Upload date
Uploaded using Trusted Publishing?
What is trusted publishing?
No
Uploaded via twine/6.1.0 CPython/3.11.3

Release files / kimimaro-5.9.0-cp313-cp313-macosx_10_13_x86_64.whl

Download URL kimimaro-5.9.0-cp313-cp313-macosx_10_13_x86_64.whl
Size 367.7 kB
Tags CPython 3.13 macOS 10.13+ x86-64
SHA-256 checksum
How to use checksums
de9099b55b0ccc344271cbe1147003916a6aac3a8b32b35b1e4655a728adb597
BLAKE2b-256 checksum
How to use checksums
02a9b27a5f0b5e1ccc14c9676b930bf9b1b78b0be060551ed84701057eb3ce26
Upload date
Uploaded using Trusted Publishing?
What is trusted publishing?
No
Uploaded via twine/6.1.0 CPython/3.11.3

Release files / kimimaro-5.9.0-cp312-cp312-win_amd64.whl

Download URL kimimaro-5.9.0-cp312-cp312-win_amd64.whl
Size 307.2 kB
Tags CPython 3.12 Windows x86-64
SHA-256 checksum
How to use checksums
15205bc645f7ff3de1a58816d6f5bcf1304e5f82dcbd686b6db7fecbea6da3eb
BLAKE2b-256 checksum
How to use checksums
4a8b910899fb8898bde1182658286f81f7f5cb55e43142df441a461d9299b226
Upload date
Uploaded using Trusted Publishing?
What is trusted publishing?
No
Uploaded via twine/6.1.0 CPython/3.11.3

Release files / kimimaro-5.9.0-cp312-cp312-win32.whl

Download URL kimimaro-5.9.0-cp312-cp312-win32.whl
Size 263.9 kB
Tags CPython 3.12 Windows x86-32
SHA-256 checksum
How to use checksums
07f6e1f6d60434ed04b605266295de7db380df2ccab05bf6c91fc3c8929ee8c0
BLAKE2b-256 checksum
How to use checksums
93433539e52324be43f4be845fa42765d2fc8dc932e140f798091e05e197ad6b
Upload date
Uploaded using Trusted Publishing?
What is trusted publishing?
No
Uploaded via twine/6.1.0 CPython/3.11.3

Release files / kimimaro-5.9.0-cp312-cp312-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl

Download URL kimimaro-5.9.0-cp312-cp312-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl
Size 2.9 MB
Tags CPython 3.12 Linux glibc 2.24+ x86-64 Linux glibc 2.28+ x86-64
SHA-256 checksum
How to use checksums
42f0fa5e6d468f636d8d8e2ef62c58006ff7871cbbca2904f2cc90aa98fd3210
BLAKE2b-256 checksum
How to use checksums
a9c61e76498917271c02ccf11bdd5cb9e171bda74e65fe5f794274926b8f09d7
Upload date
Uploaded using Trusted Publishing?
What is trusted publishing?
No
Uploaded via twine/6.1.0 CPython/3.11.3

Release files / kimimaro-5.9.0-cp312-cp312-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl

Download URL kimimaro-5.9.0-cp312-cp312-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl
Size 2.8 MB
Tags CPython 3.12 Linux glibc 2.24+ ARM64 Linux glibc 2.28+ ARM64
SHA-256 checksum
How to use checksums
88dfd7977f5ce957a34f22d9852bb2c33813c0e833ac6c633fafabeea22f6fc3
BLAKE2b-256 checksum
How to use checksums
8b7b2cd7f57d1b2d2faba10ab02b202359ccbc9d9e61e2e1b9f5d067d22efa4a
Upload date
Uploaded using Trusted Publishing?
What is trusted publishing?
No
Uploaded via twine/6.1.0 CPython/3.11.3

Release files / kimimaro-5.9.0-cp312-cp312-macosx_11_0_arm64.whl

Download URL kimimaro-5.9.0-cp312-cp312-macosx_11_0_arm64.whl
Size 337.7 kB
Tags CPython 3.12 macOS 11.0+ ARM64
SHA-256 checksum
How to use checksums
af86894438681fd138f7c2d5c0190e62b6c86d5534d6c50f294e31869e75f738
BLAKE2b-256 checksum
How to use checksums
6b837f28c8e1fe214620626a732b5fa426075c4522f9c1c8ee339ff404e8031c
Upload date
Uploaded using Trusted Publishing?
What is trusted publishing?
No
Uploaded via twine/6.1.0 CPython/3.11.3

Release files / kimimaro-5.9.0-cp312-cp312-macosx_10_13_x86_64.whl

Download URL kimimaro-5.9.0-cp312-cp312-macosx_10_13_x86_64.whl
Size 367.9 kB
Tags CPython 3.12 macOS 10.13+ x86-64
SHA-256 checksum
How to use checksums
7d31ad3fc81f190ab1d388e940b89d7d390f81279a911a9fbb4ff5eae6e1ff02
BLAKE2b-256 checksum
How to use checksums
190b768e3434d7ab34a7d3aeae18d51e3808e5c3b9bbc618e960ab04fa9ccc7f
Upload date
Uploaded using Trusted Publishing?
What is trusted publishing?
No
Uploaded via twine/6.1.0 CPython/3.11.3

Release files / kimimaro-5.9.0-cp311-cp311-win_amd64.whl

Download URL kimimaro-5.9.0-cp311-cp311-win_amd64.whl
Size 315.4 kB
Tags CPython 3.11 Windows x86-64
SHA-256 checksum
How to use checksums
6a3ce12b3e78703240dfd06c47304abbbbc6fd57bc125eed638b8e6d5b6bb937
BLAKE2b-256 checksum
How to use checksums
4a7b629406811eb908ab8c2e2b2149c6754d00c1c6bc596e08e777e66ded7954
Upload date
Uploaded using Trusted Publishing?
What is trusted publishing?
No
Uploaded via twine/6.1.0 CPython/3.11.3

Release files / kimimaro-5.9.0-cp311-cp311-win32.whl

Download URL kimimaro-5.9.0-cp311-cp311-win32.whl
Size 266.1 kB
Tags CPython 3.11 Windows x86-32
SHA-256 checksum
How to use checksums
1a2ae98bf93c76e397d752b146f028bc9da054be64060d80e1bb5f90ca5b5410
BLAKE2b-256 checksum
How to use checksums
709f22032907461b3327ad4844dc74548da231a0c5415a377a44fa90d07874c2
Upload date
Uploaded using Trusted Publishing?
What is trusted publishing?
No
Uploaded via twine/6.1.0 CPython/3.11.3

Release files / kimimaro-5.9.0-cp311-cp311-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl

Download URL kimimaro-5.9.0-cp311-cp311-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl
Size 2.9 MB
Tags CPython 3.11 Linux glibc 2.24+ x86-64 Linux glibc 2.28+ x86-64
SHA-256 checksum
How to use checksums
81fdda80009612dc84c643eb6d3f2c40d7d26240a4abea6a44553fe47d57a87c
BLAKE2b-256 checksum
How to use checksums
eb5f6151439cef0c2a8044ca68d1ed72dc4a2402ab40cbcc0f06c1cb2f7a529c
Upload date
Uploaded using Trusted Publishing?
What is trusted publishing?
No
Uploaded via twine/6.1.0 CPython/3.11.3

Release files / kimimaro-5.9.0-cp311-cp311-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl

Download URL kimimaro-5.9.0-cp311-cp311-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl
Size 2.9 MB
Tags CPython 3.11 Linux glibc 2.24+ ARM64 Linux glibc 2.28+ ARM64
SHA-256 checksum
How to use checksums
af58d3329f5cf46b2b404ace10a43525e09688d5a5b4c60a37d71f622f9bb726
BLAKE2b-256 checksum
How to use checksums
d5d4fdae872063316663b67de39e5337fc56f07948f154109eeb5af106c70491
Upload date
Uploaded using Trusted Publishing?
What is trusted publishing?
No
Uploaded via twine/6.1.0 CPython/3.11.3

Release files / kimimaro-5.9.0-cp311-cp311-macosx_11_0_arm64.whl

Download URL kimimaro-5.9.0-cp311-cp311-macosx_11_0_arm64.whl
Size 337.7 kB
Tags CPython 3.11 macOS 11.0+ ARM64
SHA-256 checksum
How to use checksums
57d346fd052ff31835626d29b9e316a0252d817d18e178ce4403b861ae5aa531
BLAKE2b-256 checksum
How to use checksums
d4d4f555a502e24e6f2fb5da31009503b45ce0fa580d5601fa87910562f449e5
Upload date
Uploaded using Trusted Publishing?
What is trusted publishing?
No
Uploaded via twine/6.1.0 CPython/3.11.3

Release files / kimimaro-5.9.0-cp311-cp311-macosx_10_9_x86_64.whl

Download URL kimimaro-5.9.0-cp311-cp311-macosx_10_9_x86_64.whl
Size 366.6 kB
Tags CPython 3.11 macOS 10.9+ x86-64
SHA-256 checksum
How to use checksums
3454a6b7e7d6c53c37a0b6c69c4780c4d67bba8208442dd24582860b4f477661
BLAKE2b-256 checksum
How to use checksums
c29786f9285a979083b12047a2ea7a9dc169462fb7355153ecf3543f457d8d83
Upload date
Uploaded using Trusted Publishing?
What is trusted publishing?
No
Uploaded via twine/6.1.0 CPython/3.11.3

Release files / kimimaro-5.9.0-cp310-cp310-win_amd64.whl

Download URL kimimaro-5.9.0-cp310-cp310-win_amd64.whl
Size 315.7 kB
Tags CPython 3.10 Windows x86-64
SHA-256 checksum
How to use checksums
8de0af4825218482aed58bedfdb0991def1747925cea74fd0b6a7da8f7fe1dcf
BLAKE2b-256 checksum
How to use checksums
bd62efa4e21ac51859567a6f080d4642e8a6e1ebb466358980033cb5640c6e82
Upload date
Uploaded using Trusted Publishing?
What is trusted publishing?
No
Uploaded via twine/6.1.0 CPython/3.11.3

Release files / kimimaro-5.9.0-cp310-cp310-win32.whl

Download URL kimimaro-5.9.0-cp310-cp310-win32.whl
Size 267.5 kB
Tags CPython 3.10 Windows x86-32
SHA-256 checksum
How to use checksums
27baa890770fbd1f110d5863757eca186fa846934ca2d8c88ece5b183fbdde30
BLAKE2b-256 checksum
How to use checksums
53b7cac5b6df1e2869c9f32c078bad9ae1bd9785547c08d2c47109eb320386c8
Upload date
Uploaded using Trusted Publishing?
What is trusted publishing?
No
Uploaded via twine/6.1.0 CPython/3.11.3

Release files / kimimaro-5.9.0-cp310-cp310-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl

Download URL kimimaro-5.9.0-cp310-cp310-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl
Size 2.8 MB
Tags CPython 3.10 Linux glibc 2.24+ x86-64 Linux glibc 2.28+ x86-64
SHA-256 checksum
How to use checksums
867a3d6775448f81dca25ef381d95a39079da9cb55786dca5f77633f8017b04f
BLAKE2b-256 checksum
How to use checksums
cca92bc7016cb74c6f834d8afa9f23be21d120c0a4234555776afa57df5eae09
Upload date
Uploaded using Trusted Publishing?
What is trusted publishing?
No
Uploaded via twine/6.1.0 CPython/3.11.3

Release files / kimimaro-5.9.0-cp310-cp310-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl

Download URL kimimaro-5.9.0-cp310-cp310-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl
Size 2.8 MB
Tags CPython 3.10 Linux glibc 2.24+ ARM64 Linux glibc 2.28+ ARM64
SHA-256 checksum
How to use checksums
760b650622ac374ce51a12fe626eff60d0a45162d93c302672d0d864a0c33241
BLAKE2b-256 checksum
How to use checksums
4d95eb024278c4cb20e6fe389516c8ab026a0c7cc71420cda4d6b5ad967ac3a3
Upload date
Uploaded using Trusted Publishing?
What is trusted publishing?
No
Uploaded via twine/6.1.0 CPython/3.11.3

Release files / kimimaro-5.9.0-cp310-cp310-macosx_11_0_arm64.whl

Download URL kimimaro-5.9.0-cp310-cp310-macosx_11_0_arm64.whl
Size 338.9 kB
Tags CPython 3.10 macOS 11.0+ ARM64
SHA-256 checksum
How to use checksums
c4e953d726342c859aab7b365a9798d249a22f4c4bf04e28be546f0bef86e2f5
BLAKE2b-256 checksum
How to use checksums
9636e3ff94bbedb8c92117ffe76c81ef3c280403c75c4d8704a5b9316c5e7468
Upload date
Uploaded using Trusted Publishing?
What is trusted publishing?
No
Uploaded via twine/6.1.0 CPython/3.11.3

Release files / kimimaro-5.9.0-cp310-cp310-macosx_10_9_x86_64.whl

Download URL kimimaro-5.9.0-cp310-cp310-macosx_10_9_x86_64.whl
Size 365.5 kB
Tags CPython 3.10 macOS 10.9+ x86-64
SHA-256 checksum
How to use checksums
d9680ca491546db4687c463ee778731aeb93f98cd572036b54af127159e7e35a
BLAKE2b-256 checksum
How to use checksums
258e489d66191fd94c0a5a3cc2c98b08bc8a70ef7e2530dcd05bc6c9aefadb9d
Upload date
Uploaded using Trusted Publishing?
What is trusted publishing?
No
Uploaded via twine/6.1.0 CPython/3.11.3

Release files / kimimaro-5.9.0-cp39-cp39-win_amd64.whl

Download URL kimimaro-5.9.0-cp39-cp39-win_amd64.whl
Size 316.0 kB
Tags CPython 3.9 Windows x86-64
SHA-256 checksum
How to use checksums
9fe991be293f2a4ca8581205ba67c29a252604d3a52b2092332f5a32bdfcd4d6
BLAKE2b-256 checksum
How to use checksums
f18f2731ab1bf2dda95dd33917e0ccb44f64ca6718b2336961d566668cb9330d
Upload date
Uploaded using Trusted Publishing?
What is trusted publishing?
No
Uploaded via twine/6.1.0 CPython/3.11.3

Release files / kimimaro-5.9.0-cp39-cp39-win32.whl

Download URL kimimaro-5.9.0-cp39-cp39-win32.whl
Size 267.4 kB
Tags CPython 3.9 Windows x86-32
SHA-256 checksum
How to use checksums
250715887693201a90b21e1b372f8213486490f8e400fd8e5838eb5020dc9daf
BLAKE2b-256 checksum
How to use checksums
f57ba91ce02387a82efa6c3088f0e66589e16e407f70a555e47d0d4221c5e3bb
Upload date
Uploaded using Trusted Publishing?
What is trusted publishing?
No
Uploaded via twine/6.1.0 CPython/3.11.3

Release files / kimimaro-5.9.0-cp39-cp39-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl

Download URL kimimaro-5.9.0-cp39-cp39-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl
Size 2.8 MB
Tags CPython 3.9 Linux glibc 2.24+ x86-64 Linux glibc 2.28+ x86-64
SHA-256 checksum
How to use checksums
d9bf98ede41031b42254ba903faf1a8233233364d9a91effd639c1c95d23469e
BLAKE2b-256 checksum
How to use checksums
7938bbb7ef418b26a924c580f019c52d1e86ebf622092b982167aeb8d12103bb
Upload date
Uploaded using Trusted Publishing?
What is trusted publishing?
No
Uploaded via twine/6.1.0 CPython/3.11.3

Release files / kimimaro-5.9.0-cp39-cp39-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl

Download URL kimimaro-5.9.0-cp39-cp39-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl
Size 2.7 MB
Tags CPython 3.9 Linux glibc 2.24+ ARM64 Linux glibc 2.28+ ARM64
SHA-256 checksum
How to use checksums
742f85825b4b3a10cbbe98c0e61a5436f50cef83764d2de3d62c9616ae065f6d
BLAKE2b-256 checksum
How to use checksums
cdc346d592233c84878da5949961de7f4b84e573477896c0830ed3b3d55e25ea
Upload date
Uploaded using Trusted Publishing?
What is trusted publishing?
No
Uploaded via twine/6.1.0 CPython/3.11.3

Release files / kimimaro-5.9.0-cp39-cp39-macosx_11_0_arm64.whl

Download URL kimimaro-5.9.0-cp39-cp39-macosx_11_0_arm64.whl
Size 339.6 kB
Tags CPython 3.9 macOS 11.0+ ARM64
SHA-256 checksum
How to use checksums
4480ba69de4af655acc91be0074dd8f4dad9ec9cc70dd1879aa11837eb780f6b
BLAKE2b-256 checksum
How to use checksums
a54ce49390cd2a91a73094eb8b64e8751629d68d0be3eaf75aca6fdd0ae9445b
Upload date
Uploaded using Trusted Publishing?
What is trusted publishing?
No
Uploaded via twine/6.1.0 CPython/3.11.3

Release files / kimimaro-5.9.0-cp39-cp39-macosx_10_9_x86_64.whl

Download URL kimimaro-5.9.0-cp39-cp39-macosx_10_9_x86_64.whl
Size 365.7 kB
Tags CPython 3.9 macOS 10.9+ x86-64
SHA-256 checksum
How to use checksums
92deb997d0c992a8a588651aa2ab8a85969f313ad6963f130afd3719726c040f
BLAKE2b-256 checksum
How to use checksums
5748a4940b87475755c88f1f89a04af44a80911863f857f860b83e15274fb1ec
Upload date
Uploaded using Trusted Publishing?
What is trusted publishing?
No
Uploaded via twine/6.1.0 CPython/3.11.3

Security for kimimaro 5.9.0

Provenance

Provenance describes where a file came from. On PyPI, provenance is shared via attestations, which provide a verifiable record of the build or publishing details. View details, limitations and caveats.

No provenance found

None of the files in this release were uploaded with provenance metadata.

A note on package security

PyPI is a repository for distributing packages, not a service for auditing them. While third-party security researchers and our staff do their best to detect and remove malicious packages, PyPI cannot guarantee the quality, security or suitability of any given package.

To learn more about protecting yourself from malicious actors, visit our package security documentation.

Release history Release notifications | RSS feed

This release

5.9.0 This release

43 release files No provenance

Anthropic, PBC Visionary sponsor Bloomberg Visionary sponsor Hudson River Trading Visionary sponsor Meta Visionary sponsor NVIDIA Visionary sponsor Microsoft Sustainability sponsor Depot Continuous Integration AWS Cloud computing and Security Sponsor Datadog Monitoring Fastly CDN Google Download Analytics Sentry Error logging StatusPage Status page