diff --git a/Makefile b/Makefile index 6f394ff55..29fb647f0 100644 --- a/Makefile +++ b/Makefile @@ -154,8 +154,7 @@ add-header: # Apply the Apache 2.0 license header to DEIMv2 derived files uv run --frozen licenseheaders -t dev_tools/deimv2_licenseheader.tmpl \ - -f src/lightly_train/_task_models/dinov2_ltdetr_object_detection/dinov2_vit_wrapper.py \ - src/lightly_train/_task_models/dinov3_ltdetr_object_detection/dinov3_vit_wrapper.py \ + -f src/lightly_train/_task_models/dinov3_ltdetr_object_detection/dinov3_vit_wrapper.py \ src/lightly_train/_task_models/object_detection_components/flat_cosine.py \ -E py diff --git a/pyproject.toml b/pyproject.toml index 9c10a0662..7b063bbd9 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -37,18 +37,19 @@ dependencies = [ "nvidia-ml-py>=12", # For GPU monitoring "pytorch_lightning>=2.1", "tensorboard>=2.10.0", - "torch>=2.1.0", + "torch>=2.1.0", "torchmetrics[detection]>=0.8", # Torchmetrics is needed for fine-tuning. - # 0.8 is required by SuperGradients - # 1.5.2 is the last version that supports Python 3.8 - # 1.7 is recommended version + # 0.8 is required by SuperGradients + # 1.5.2 is the last version that supports Python 3.8 + # 1.7 is recommended version "torchvision>=0.16.0", # torchvision 0.15.0 was yanked "transformers>=4.46", # Transformers is needed for fine-tuning. - # 4.46 is last version that supports Python 3.8. - # 4.51.3 is the default for EoMT + # 4.46 is last version that supports Python 3.8. + # 4.51.3 is the default for EoMT "tqdm>=4.0.0", "pycocotools>=2.0.11; python_version>='3.9'", "numpy>1.23.0; python_version>='3.12'", # numpy<=1.23 fails to build on Python>3.12 (no distutils). + ] [dependency-groups] @@ -190,7 +191,8 @@ ignore_missing_imports = true module = [ "lightly_train._models.dinov2_vit.dinov2_vit_src.*", "lightly_train._models.dinov3.dinov3_src.*", - "lightly_train._task_models.object_detection_components.*" + "lightly_train._task_models.object_detection_components.*", + "lightly_train._models.fastvit.components.*", ] ignore_errors = true diff --git a/src/lightly_train/_commands/train_task_helpers.py b/src/lightly_train/_commands/train_task_helpers.py index 3c1faee18..b57106a64 100644 --- a/src/lightly_train/_commands/train_task_helpers.py +++ b/src/lightly_train/_commands/train_task_helpers.py @@ -61,9 +61,6 @@ from lightly_train._task_models.dinov2_linear_semantic_segmentation.train_model import ( DINOv2LinearSemanticSegmentationTrain, ) -from lightly_train._task_models.dinov2_ltdetr_object_detection.train_model import ( - DINOv2LTDETRObjectDetectionTrain, -) from lightly_train._task_models.dinov3_eomt_instance_segmentation.train_model import ( DINOv3EoMTInstanceSegmentationTrain, ) @@ -129,7 +126,6 @@ DINOv2LinearSemanticSegmentationTrain, DINOv3EoMTSemanticSegmentationTrain, SemanticSegmentationMultiheadTrain, - DINOv2LTDETRObjectDetectionTrain, DINOv3LTDETRObjectDetectionTrain, PicoDetObjectDetectionTrain, ] diff --git a/src/lightly_train/_models/dinov2_vit/dinov2_vit.py b/src/lightly_train/_models/dinov2_vit/dinov2_vit.py index 1edb16744..fc1244eef 100644 --- a/src/lightly_train/_models/dinov2_vit/dinov2_vit.py +++ b/src/lightly_train/_models/dinov2_vit/dinov2_vit.py @@ -22,13 +22,11 @@ ArchitectureInfoGettable, ForwardFeaturesOutput, ForwardPoolOutput, - MultiScaleFeatureModelWrapper, + MultiScaleFeatureViT, ) -class DINOv2ViTModelWrapper( - Module, MultiScaleFeatureModelWrapper, ArchitectureInfoGettable -): +class DINOv2ViTModelWrapper(Module, MultiScaleFeatureViT, ArchitectureInfoGettable): def __init__(self, model: DinoVisionTransformer) -> None: super().__init__() self._model = model @@ -37,6 +35,9 @@ def __init__(self, model: DinoVisionTransformer) -> None: def feature_dim(self) -> int: return self._feature_dim + def patch_size(self) -> int: + return int(self._model.patch_size) + def forward_features( self, x: Tensor, masks: Tensor | None = None, n_blocks: int = 1 ) -> ForwardFeaturesOutput: diff --git a/src/lightly_train/_models/dinov3/dinov3_convnext.py b/src/lightly_train/_models/dinov3/dinov3_convnext.py index 5c928211c..aa7f201f9 100644 --- a/src/lightly_train/_models/dinov3/dinov3_convnext.py +++ b/src/lightly_train/_models/dinov3/dinov3_convnext.py @@ -12,17 +12,17 @@ import torch import torch.nn.functional as F from torch import Tensor -from torch.nn import AdaptiveAvgPool2d, Module +from torch.nn import AdaptiveAvgPool2d, Conv2d, Module from lightly_train._models.dinov3.dinov3_src.models.convnext import ConvNeXt from lightly_train._models.model_wrapper import ( ForwardFeaturesOutput, ForwardPoolOutput, - MultiScaleFeatureModelWrapper, + MultiScaleFeatureCNN, ) -class DINOv3VConvNeXtModelWrapper(Module, MultiScaleFeatureModelWrapper): +class DINOv3VConvNeXtModelWrapper(Module, MultiScaleFeatureCNN): def __init__(self, model: ConvNeXt) -> None: super().__init__() self._model = model @@ -83,6 +83,16 @@ def get_model(self) -> ConvNeXt: def make_teacher(self) -> None: pass + def multiscale_feature_strides(self) -> list[int]: + strides = [] + cumulative = 1 + for stage in self._model.downsample_layers: + for mod in stage: + if isinstance(mod, Conv2d): + cumulative *= mod.stride[0] + strides.append(cumulative) + return strides + def multiscale_feature_dims(self) -> list[int]: return list(self._model.embed_dims) diff --git a/src/lightly_train/_models/dinov3/dinov3_src/models/convnext.py b/src/lightly_train/_models/dinov3/dinov3_src/models/convnext.py index cbcb390f4..3292898e6 100644 --- a/src/lightly_train/_models/dinov3/dinov3_src/models/convnext.py +++ b/src/lightly_train/_models/dinov3/dinov3_src/models/convnext.py @@ -158,7 +158,7 @@ def __init__( del ignored_kwargs # ==== ConvNeXt's original init ===== - self.downsample_layers = ( + self.downsample_layers: Sequence[nn.Sequential] = ( nn.ModuleList() ) # stem and 3 intermediate downsampling conv layers stem = nn.Sequential( diff --git a/src/lightly_train/_models/dinov3/dinov3_vit.py b/src/lightly_train/_models/dinov3/dinov3_vit.py index 6b7d6365b..8ddc43edc 100644 --- a/src/lightly_train/_models/dinov3/dinov3_vit.py +++ b/src/lightly_train/_models/dinov3/dinov3_vit.py @@ -24,13 +24,11 @@ ArchitectureInfoGettable, ForwardFeaturesOutput, ForwardPoolOutput, - MultiScaleFeatureModelWrapper, + MultiScaleFeatureViT, ) -class DINOv3ViTModelWrapper( - Module, MultiScaleFeatureModelWrapper, ArchitectureInfoGettable -): +class DINOv3ViTModelWrapper(Module, MultiScaleFeatureViT, ArchitectureInfoGettable): def __init__(self, model: DinoVisionTransformer) -> None: super().__init__() self._model = model @@ -39,6 +37,9 @@ def __init__(self, model: DinoVisionTransformer) -> None: def feature_dim(self) -> int: return self._feature_dim + def patch_size(self) -> int: + return int(self._model.patch_size) + def forward_features( self, x: Tensor, masks: Tensor | None = None, n_blocks: int = 1 ) -> ForwardFeaturesOutput: diff --git a/tests/_task_models/dinov2_ltdetr_object_detection/__init__.py b/src/lightly_train/_models/fastvit/__init__.py similarity index 100% rename from tests/_task_models/dinov2_ltdetr_object_detection/__init__.py rename to src/lightly_train/_models/fastvit/__init__.py diff --git a/src/lightly_train/_models/fastvit/components/__init__.py b/src/lightly_train/_models/fastvit/components/__init__.py new file mode 100644 index 000000000..80cae297b --- /dev/null +++ b/src/lightly_train/_models/fastvit/components/__init__.py @@ -0,0 +1,7 @@ +# +# Copyright (c) Lightly AG and affiliates. +# All rights reserved. +# +# This source code is licensed under the license found in the +# LICENSE file in the root directory of this source tree. +# diff --git a/src/lightly_train/_models/fastvit/components/models/__init__.py b/src/lightly_train/_models/fastvit/components/models/__init__.py new file mode 100644 index 000000000..61972effd --- /dev/null +++ b/src/lightly_train/_models/fastvit/components/models/__init__.py @@ -0,0 +1,26 @@ +# +# Copyright (c) Lightly AG and affiliates. +# All rights reserved. +# +# This source code is licensed under the license found in the +# LICENSE file in the root directory of this source tree. +# +from .fastvit import ( + fastvit_ma36, + fastvit_s12, + fastvit_sa12, + fastvit_sa24, + fastvit_sa36, + fastvit_t8, + fastvit_t12, +) + +__all__ = [ + "fastvit_t8", + "fastvit_t12", + "fastvit_s12", + "fastvit_sa12", + "fastvit_sa24", + "fastvit_sa36", + "fastvit_ma36", +] diff --git a/src/lightly_train/_models/fastvit/components/models/fastvit.py b/src/lightly_train/_models/fastvit/components/models/fastvit.py new file mode 100644 index 000000000..644485164 --- /dev/null +++ b/src/lightly_train/_models/fastvit/components/models/fastvit.py @@ -0,0 +1,1116 @@ +# +# Copyright (c) Lightly AG and affiliates. +# All rights reserved. +# +# This source code is licensed under the license found in the +# LICENSE file in the root directory of this source tree. +# +import copy +import os +from functools import partial +from typing import List, Optional, Tuple, Union + +import torch +import torch.nn as nn +from timm.data import IMAGENET_DEFAULT_MEAN, IMAGENET_DEFAULT_STD +from timm.models.layers import DropPath, trunc_normal_ +from timm.models.registry import register_model + +from .modules.mobileone import MobileOneBlock +from .modules.replknet import ReparamLargeKernelConv + +try: + from mmcv.runner import _load_checkpoint + from mmseg.utils import get_root_logger + + has_mmseg = True +except ImportError: + print("If for semantic segmentation, please install mmsegmentation first") + has_mmseg = False + +try: + from mmcv.runner import _load_checkpoint + from mmdet.utils import get_root_logger + + has_mmdet = True +except ImportError: + print("If for detection, please install mmdetection first") + has_mmdet = False + + +def _cfg(url="", **kwargs): + return { + "url": url, + "num_classes": 1000, + "input_size": (3, 256, 256), + "pool_size": None, + "crop_pct": 0.95, + "interpolation": "bicubic", + "mean": IMAGENET_DEFAULT_MEAN, + "std": IMAGENET_DEFAULT_STD, + "classifier": "head", + **kwargs, + } + + +default_cfgs = { + "fastvit_t": _cfg(crop_pct=0.9), + "fastvit_s": _cfg(crop_pct=0.9), + "fastvit_m": _cfg(crop_pct=0.95), +} + + +def convolutional_stem( + in_channels: int, out_channels: int, inference_mode: bool = False +) -> nn.Sequential: + """Build convolutional stem with MobileOne blocks. + + Args: + in_channels: Number of input channels. + out_channels: Number of output channels. + inference_mode: Flag to instantiate model in inference mode. Default: ``False`` + + Returns: + nn.Sequential object with stem elements. + """ + return nn.Sequential( + MobileOneBlock( + in_channels=in_channels, + out_channels=out_channels, + kernel_size=3, + stride=2, + padding=1, + groups=1, + inference_mode=inference_mode, + use_se=False, + num_conv_branches=1, + ), + MobileOneBlock( + in_channels=out_channels, + out_channels=out_channels, + kernel_size=3, + stride=2, + padding=1, + groups=out_channels, + inference_mode=inference_mode, + use_se=False, + num_conv_branches=1, + ), + MobileOneBlock( + in_channels=out_channels, + out_channels=out_channels, + kernel_size=1, + stride=1, + padding=0, + groups=1, + inference_mode=inference_mode, + use_se=False, + num_conv_branches=1, + ), + ) + + +class MHSA(nn.Module): + """Multi-headed Self Attention module. + + Source modified from: + https://github.com/rwightman/pytorch-image-models/blob/master/timm/models/vision_transformer.py + """ + + def __init__( + self, + dim: int, + head_dim: int = 32, + qkv_bias: bool = False, + attn_drop: float = 0.0, + proj_drop: float = 0.0, + ) -> None: + """Build MHSA module that can handle 3D or 4D input tensors. + + Args: + dim: Number of embedding dimensions. + head_dim: Number of hidden dimensions per head. Default: ``32`` + qkv_bias: Use bias or not. Default: ``False`` + attn_drop: Dropout rate for attention tensor. + proj_drop: Dropout rate for projection tensor. + """ + super().__init__() + assert dim % head_dim == 0, "dim should be divisible by head_dim" + self.head_dim = head_dim + self.num_heads = dim // head_dim + self.scale = head_dim**-0.5 + + self.qkv = nn.Linear(dim, dim * 3, bias=qkv_bias) + self.attn_drop = nn.Dropout(attn_drop) + self.proj = nn.Linear(dim, dim) + self.proj_drop = nn.Dropout(proj_drop) + + def forward(self, x: torch.Tensor) -> torch.Tensor: + shape = x.shape + B, C, H, W = shape + N = H * W + if len(shape) == 4: + x = torch.flatten(x, start_dim=2).transpose(-2, -1) # (B, N, C) + qkv = ( + self.qkv(x) + .reshape(B, N, 3, self.num_heads, self.head_dim) + .permute(2, 0, 3, 1, 4) + ) + q, k, v = qkv.unbind(0) # make torchscript happy (cannot use tensor as tuple) + + # trick here to make q@k.t more stable + attn = (q * self.scale) @ k.transpose(-2, -1) + attn = attn.softmax(dim=-1) + attn = self.attn_drop(attn) + + x = (attn @ v).transpose(1, 2).reshape(B, N, C) + x = self.proj(x) + x = self.proj_drop(x) + if len(shape) == 4: + x = x.transpose(-2, -1).reshape(B, C, H, W) + + return x + + +class PatchEmbed(nn.Module): + """Convolutional patch embedding layer.""" + + def __init__( + self, + patch_size: int, + stride: int, + in_channels: int, + embed_dim: int, + inference_mode: bool = False, + ) -> None: + """Build patch embedding layer. + + Args: + patch_size: Patch size for embedding computation. + stride: Stride for convolutional embedding layer. + in_channels: Number of channels of input tensor. + embed_dim: Number of embedding dimensions. + inference_mode: Flag to instantiate model in inference mode. Default: ``False`` + """ + super().__init__() + block = list() + block.append( + ReparamLargeKernelConv( + in_channels=in_channels, + out_channels=embed_dim, + kernel_size=patch_size, + stride=stride, + groups=in_channels, + small_kernel=3, + inference_mode=inference_mode, + ) + ) + block.append( + MobileOneBlock( + in_channels=embed_dim, + out_channels=embed_dim, + kernel_size=1, + stride=1, + padding=0, + groups=1, + inference_mode=inference_mode, + use_se=False, + num_conv_branches=1, + ) + ) + self.proj = nn.Sequential(*block) + + def forward(self, x: torch.Tensor) -> torch.Tensor: + x = self.proj(x) + return x + + +class RepMixer(nn.Module): + """Reparameterizable token mixer. + + For more details, please refer to our paper: + `FastViT: A Fast Hybrid Vision Transformer using Structural Reparameterization `_ + """ + + def __init__( + self, + dim, + kernel_size=3, + use_layer_scale=True, + layer_scale_init_value=1e-5, + inference_mode: bool = False, + ): + """Build RepMixer Module. + + Args: + dim: Input feature map dimension. :math:`C_{in}` from an expected input of size :math:`(B, C_{in}, H, W)`. + kernel_size: Kernel size for spatial mixing. Default: 3 + use_layer_scale: If True, learnable layer scale is used. Default: ``True`` + layer_scale_init_value: Initial value for layer scale. Default: 1e-5 + inference_mode: If True, instantiates model in inference mode. Default: ``False`` + """ + super().__init__() + self.dim = dim + self.kernel_size = kernel_size + self.inference_mode = inference_mode + + if inference_mode: + self.reparam_conv = nn.Conv2d( + in_channels=self.dim, + out_channels=self.dim, + kernel_size=self.kernel_size, + stride=1, + padding=self.kernel_size // 2, + groups=self.dim, + bias=True, + ) + else: + self.norm = MobileOneBlock( + dim, + dim, + kernel_size, + padding=kernel_size // 2, + groups=dim, + use_act=False, + use_scale_branch=False, + num_conv_branches=0, + ) + self.mixer = MobileOneBlock( + dim, + dim, + kernel_size, + padding=kernel_size // 2, + groups=dim, + use_act=False, + ) + self.use_layer_scale = use_layer_scale + if use_layer_scale: + self.layer_scale = nn.Parameter( + layer_scale_init_value * torch.ones((dim, 1, 1)), requires_grad=True + ) + + def forward(self, x: torch.Tensor) -> torch.Tensor: + if hasattr(self, "reparam_conv"): + x = self.reparam_conv(x) + return x + else: + if self.use_layer_scale: + x = x + self.layer_scale * (self.mixer(x) - self.norm(x)) + else: + x = x + self.mixer(x) - self.norm(x) + return x + + def reparameterize(self) -> None: + """Reparameterize mixer and norm into a single + convolutional layer for efficient inference. + """ + if self.inference_mode: + return + + self.mixer.reparameterize() + self.norm.reparameterize() + + if self.use_layer_scale: + w = self.mixer.id_tensor + self.layer_scale.unsqueeze(-1) * ( + self.mixer.reparam_conv.weight - self.norm.reparam_conv.weight + ) + b = torch.squeeze(self.layer_scale) * ( + self.mixer.reparam_conv.bias - self.norm.reparam_conv.bias + ) + else: + w = ( + self.mixer.id_tensor + + self.mixer.reparam_conv.weight + - self.norm.reparam_conv.weight + ) + b = self.mixer.reparam_conv.bias - self.norm.reparam_conv.bias + + self.reparam_conv = nn.Conv2d( + in_channels=self.dim, + out_channels=self.dim, + kernel_size=self.kernel_size, + stride=1, + padding=self.kernel_size // 2, + groups=self.dim, + bias=True, + ) + self.reparam_conv.weight.data = w + self.reparam_conv.bias.data = b + + for para in self.parameters(): + para.detach_() + self.__delattr__("mixer") + self.__delattr__("norm") + if self.use_layer_scale: + self.__delattr__("layer_scale") + + +class ConvFFN(nn.Module): + """Convolutional FFN Module.""" + + def __init__( + self, + in_channels: int, + hidden_channels: Optional[int] = None, + out_channels: Optional[int] = None, + act_layer: nn.Module = nn.GELU, + drop: float = 0.0, + ) -> None: + """Build convolutional FFN module. + + Args: + in_channels: Number of input channels. + hidden_channels: Number of channels after expansion. Default: None + out_channels: Number of output channels. Default: None + act_layer: Activation layer. Default: ``GELU`` + drop: Dropout rate. Default: ``0.0``. + """ + super().__init__() + out_channels = out_channels or in_channels + hidden_channels = hidden_channels or in_channels + self.conv = nn.Sequential() + self.conv.add_module( + "conv", + nn.Conv2d( + in_channels=in_channels, + out_channels=out_channels, + kernel_size=7, + padding=3, + groups=in_channels, + bias=False, + ), + ) + self.conv.add_module("bn", nn.BatchNorm2d(num_features=out_channels)) + self.fc1 = nn.Conv2d(in_channels, hidden_channels, kernel_size=1) + self.act = act_layer() + self.fc2 = nn.Conv2d(hidden_channels, out_channels, kernel_size=1) + self.drop = nn.Dropout(drop) + self.apply(self._init_weights) + + def _init_weights(self, m: nn.Module) -> None: + if isinstance(m, nn.Conv2d): + trunc_normal_(m.weight, std=0.02) + if m.bias is not None: + nn.init.constant_(m.bias, 0) + + def forward(self, x: torch.Tensor) -> torch.Tensor: + x = self.conv(x) + x = self.fc1(x) + x = self.act(x) + x = self.drop(x) + x = self.fc2(x) + x = self.drop(x) + return x + + +class RepCPE(nn.Module): + """Implementation of conditional positional encoding. + + For more details refer to paper: + `Conditional Positional Encodings for Vision Transformers `_ + + In our implementation, we can reparameterize this module to eliminate a skip connection. + """ + + def __init__( + self, + in_channels: int, + embed_dim: int = 768, + spatial_shape: Union[int, Tuple[int, int]] = (7, 7), + inference_mode=False, + ) -> None: + """Build reparameterizable conditional positional encoding + + Args: + in_channels: Number of input channels. + embed_dim: Number of embedding dimensions. Default: 768 + spatial_shape: Spatial shape of kernel for positional encoding. Default: (7, 7) + inference_mode: Flag to instantiate block in inference mode. Default: ``False`` + """ + super(RepCPE, self).__init__() + if isinstance(spatial_shape, int): + spatial_shape = tuple([spatial_shape] * 2) + assert isinstance(spatial_shape, Tuple), ( + f'"spatial_shape" must by a sequence or int, ' + f"get {type(spatial_shape)} instead." + ) + assert len(spatial_shape) == 2, ( + f'Length of "spatial_shape" should be 2, got {len(spatial_shape)} instead.' + ) + + self.spatial_shape = spatial_shape + self.embed_dim = embed_dim + self.in_channels = in_channels + self.groups = embed_dim + + if inference_mode: + self.reparam_conv = nn.Conv2d( + in_channels=self.in_channels, + out_channels=self.embed_dim, + kernel_size=self.spatial_shape, + stride=1, + padding=int(self.spatial_shape[0] // 2), + groups=self.embed_dim, + bias=True, + ) + else: + self.pe = nn.Conv2d( + in_channels, + embed_dim, + spatial_shape, + 1, + int(spatial_shape[0] // 2), + bias=True, + groups=embed_dim, + ) + + def forward(self, x: torch.Tensor) -> torch.Tensor: + if hasattr(self, "reparam_conv"): + x = self.reparam_conv(x) + return x + else: + x = self.pe(x) + x + return x + + def reparameterize(self) -> None: + # Build equivalent Id tensor + input_dim = self.in_channels // self.groups + kernel_value = torch.zeros( + ( + self.in_channels, + input_dim, + self.spatial_shape[0], + self.spatial_shape[1], + ), + dtype=self.pe.weight.dtype, + device=self.pe.weight.device, + ) + for i in range(self.in_channels): + kernel_value[ + i, + i % input_dim, + self.spatial_shape[0] // 2, + self.spatial_shape[1] // 2, + ] = 1 + id_tensor = kernel_value + + # Reparameterize Id tensor and conv + w_final = id_tensor + self.pe.weight + b_final = self.pe.bias + + # Introduce reparam conv + self.reparam_conv = nn.Conv2d( + in_channels=self.in_channels, + out_channels=self.embed_dim, + kernel_size=self.spatial_shape, + stride=1, + padding=int(self.spatial_shape[0] // 2), + groups=self.embed_dim, + bias=True, + ) + self.reparam_conv.weight.data = w_final + self.reparam_conv.bias.data = b_final + + for para in self.parameters(): + para.detach_() + self.__delattr__("pe") + + +class RepMixerBlock(nn.Module): + """Implementation of Metaformer block with RepMixer as token mixer. + + For more details on Metaformer structure, please refer to: + `MetaFormer Is Actually What You Need for Vision `_ + """ + + def __init__( + self, + dim: int, + kernel_size: int = 3, + mlp_ratio: float = 4.0, + act_layer: nn.Module = nn.GELU, + drop: float = 0.0, + drop_path: float = 0.0, + use_layer_scale: bool = True, + layer_scale_init_value: float = 1e-5, + inference_mode: bool = False, + ): + """Build RepMixer Block. + + Args: + dim: Number of embedding dimensions. + kernel_size: Kernel size for repmixer. Default: 3 + mlp_ratio: MLP expansion ratio. Default: 4.0 + act_layer: Activation layer. Default: ``nn.GELU`` + drop: Dropout rate. Default: 0.0 + drop_path: Drop path rate. Default: 0.0 + use_layer_scale: Flag to turn on layer scale. Default: ``True`` + layer_scale_init_value: Layer scale value at initialization. Default: 1e-5 + inference_mode: Flag to instantiate block in inference mode. Default: ``False`` + """ + + super().__init__() + + self.token_mixer = RepMixer( + dim, + kernel_size=kernel_size, + use_layer_scale=use_layer_scale, + layer_scale_init_value=layer_scale_init_value, + inference_mode=inference_mode, + ) + + assert mlp_ratio > 0, "MLP ratio should be greater than 0, found: {}".format( + mlp_ratio + ) + mlp_hidden_dim = int(dim * mlp_ratio) + self.convffn = ConvFFN( + in_channels=dim, + hidden_channels=mlp_hidden_dim, + act_layer=act_layer, + drop=drop, + ) + + # Drop Path + self.drop_path = DropPath(drop_path) if drop_path > 0.0 else nn.Identity() + + # Layer Scale + self.use_layer_scale = use_layer_scale + if use_layer_scale: + self.layer_scale = nn.Parameter( + layer_scale_init_value * torch.ones((dim, 1, 1)), requires_grad=True + ) + + def forward(self, x): + if self.use_layer_scale: + x = self.token_mixer(x) + x = x + self.drop_path(self.layer_scale * self.convffn(x)) + else: + x = self.token_mixer(x) + x = x + self.drop_path(self.convffn(x)) + return x + + +class AttentionBlock(nn.Module): + """Implementation of metaformer block with MHSA as token mixer. + + For more details on Metaformer structure, please refer to: + `MetaFormer Is Actually What You Need for Vision `_ + """ + + def __init__( + self, + dim: int, + mlp_ratio: float = 4.0, + act_layer: nn.Module = nn.GELU, + norm_layer: nn.Module = nn.BatchNorm2d, + drop: float = 0.0, + drop_path: float = 0.0, + use_layer_scale: bool = True, + layer_scale_init_value: float = 1e-5, + ): + """Build Attention Block. + + Args: + dim: Number of embedding dimensions. + mlp_ratio: MLP expansion ratio. Default: 4.0 + act_layer: Activation layer. Default: ``nn.GELU`` + norm_layer: Normalization layer. Default: ``nn.BatchNorm2d`` + drop: Dropout rate. Default: 0.0 + drop_path: Drop path rate. Default: 0.0 + use_layer_scale: Flag to turn on layer scale. Default: ``True`` + layer_scale_init_value: Layer scale value at initialization. Default: 1e-5 + """ + + super().__init__() + + self.norm = norm_layer(dim) + self.token_mixer = MHSA(dim=dim) + + assert mlp_ratio > 0, "MLP ratio should be greater than 0, found: {}".format( + mlp_ratio + ) + mlp_hidden_dim = int(dim * mlp_ratio) + self.convffn = ConvFFN( + in_channels=dim, + hidden_channels=mlp_hidden_dim, + act_layer=act_layer, + drop=drop, + ) + + # Drop path + self.drop_path = DropPath(drop_path) if drop_path > 0.0 else nn.Identity() + + # Layer Scale + self.use_layer_scale = use_layer_scale + if use_layer_scale: + self.layer_scale_1 = nn.Parameter( + layer_scale_init_value * torch.ones((dim, 1, 1)), requires_grad=True + ) + self.layer_scale_2 = nn.Parameter( + layer_scale_init_value * torch.ones((dim, 1, 1)), requires_grad=True + ) + + def forward(self, x): + if self.use_layer_scale: + x = x + self.drop_path(self.layer_scale_1 * self.token_mixer(self.norm(x))) + x = x + self.drop_path(self.layer_scale_2 * self.convffn(x)) + else: + x = x + self.drop_path(self.token_mixer(self.norm(x))) + x = x + self.drop_path(self.convffn(x)) + return x + + +def basic_blocks( + dim: int, + block_index: int, + num_blocks: List[int], + token_mixer_type: str, + kernel_size: int = 3, + mlp_ratio: float = 4.0, + act_layer: nn.Module = nn.GELU, + norm_layer: nn.Module = nn.BatchNorm2d, + drop_rate: float = 0.0, + drop_path_rate: float = 0.0, + use_layer_scale: bool = True, + layer_scale_init_value: float = 1e-5, + inference_mode=False, +) -> nn.Sequential: + """Build FastViT blocks within a stage. + + Args: + dim: Number of embedding dimensions. + block_index: block index. + num_blocks: List containing number of blocks per stage. + token_mixer_type: Token mixer type. + kernel_size: Kernel size for repmixer. + mlp_ratio: MLP expansion ratio. + act_layer: Activation layer. + norm_layer: Normalization layer. + drop_rate: Dropout rate. + drop_path_rate: Drop path rate. + use_layer_scale: Flag to turn on layer scale regularization. + layer_scale_init_value: Layer scale value at initialization. + inference_mode: Flag to instantiate block in inference mode. + + Returns: + nn.Sequential object of all the blocks within the stage. + """ + blocks = [] + for block_idx in range(num_blocks[block_index]): + block_dpr = ( + drop_path_rate + * (block_idx + sum(num_blocks[:block_index])) + / (sum(num_blocks) - 1) + ) + if token_mixer_type == "repmixer": + blocks.append( + RepMixerBlock( + dim, + kernel_size=kernel_size, + mlp_ratio=mlp_ratio, + act_layer=act_layer, + drop=drop_rate, + drop_path=block_dpr, + use_layer_scale=use_layer_scale, + layer_scale_init_value=layer_scale_init_value, + inference_mode=inference_mode, + ) + ) + elif token_mixer_type == "attention": + blocks.append( + AttentionBlock( + dim, + mlp_ratio=mlp_ratio, + act_layer=act_layer, + norm_layer=norm_layer, + drop=drop_rate, + drop_path=block_dpr, + use_layer_scale=use_layer_scale, + layer_scale_init_value=layer_scale_init_value, + ) + ) + else: + raise ValueError( + "Token mixer type: {} not supported".format(token_mixer_type) + ) + blocks = nn.Sequential(*blocks) + + return blocks + + +class FastViT(nn.Module): + """ + This class implements `FastViT architecture `_ + """ + + def __init__( + self, + layers, + token_mixers: Tuple[str, ...], + embed_dims=None, + mlp_ratios=None, + downsamples=None, + repmixer_kernel_size=3, + norm_layer: nn.Module = nn.BatchNorm2d, + act_layer: nn.Module = nn.GELU, + num_classes=1000, + pos_embs=None, + down_patch_size=7, + down_stride=2, + drop_rate=0.0, + drop_path_rate=0.0, + use_layer_scale=True, + layer_scale_init_value=1e-5, + fork_feat=False, + init_cfg=None, + pretrained=None, + cls_ratio=2.0, + inference_mode=False, + **kwargs, + ) -> None: + + super().__init__() + + if not fork_feat: + self.num_classes = num_classes + self.fork_feat = fork_feat + + if pos_embs is None: + pos_embs = [None] * len(layers) + + # Convolutional stem + self.patch_embed = convolutional_stem(3, embed_dims[0], inference_mode) + + # Build the main stages of the network architecture + network = [] + for i in range(len(layers)): + # Add position embeddings if requested + if pos_embs[i] is not None: + network.append( + pos_embs[i]( + embed_dims[i], embed_dims[i], inference_mode=inference_mode + ) + ) + stage = basic_blocks( + embed_dims[i], + i, + layers, + token_mixer_type=token_mixers[i], + kernel_size=repmixer_kernel_size, + mlp_ratio=mlp_ratios[i], + act_layer=act_layer, + norm_layer=norm_layer, + drop_rate=drop_rate, + drop_path_rate=drop_path_rate, + use_layer_scale=use_layer_scale, + layer_scale_init_value=layer_scale_init_value, + inference_mode=inference_mode, + ) + network.append(stage) + if i >= len(layers) - 1: + break + + # Patch merging/downsampling between stages. + if downsamples[i] or embed_dims[i] != embed_dims[i + 1]: + network.append( + PatchEmbed( + patch_size=down_patch_size, + stride=down_stride, + in_channels=embed_dims[i], + embed_dim=embed_dims[i + 1], + inference_mode=inference_mode, + ) + ) + + self.network = nn.ModuleList(network) + + # For segmentation and detection, extract intermediate output + if self.fork_feat: + # add a norm layer for each output + self.out_indices = [0, 2, 4, 6] + for i_emb, i_layer in enumerate(self.out_indices): + if i_emb == 0 and os.environ.get("FORK_LAST3", None): + """For RetinaNet, `start_level=1`. The first norm layer will not used. + cmd: `FORK_LAST3=1 python -m torch.distributed.launch ...` + """ + layer = nn.Identity() + else: + layer = norm_layer(embed_dims[i_emb]) + layer_name = f"norm{i_layer}" + self.add_module(layer_name, layer) + else: + # Classifier head + self.gap = nn.AdaptiveAvgPool2d(output_size=1) + self.conv_exp = MobileOneBlock( + in_channels=embed_dims[-1], + out_channels=int(embed_dims[-1] * cls_ratio), + kernel_size=3, + stride=1, + padding=1, + groups=embed_dims[-1], + inference_mode=inference_mode, + use_se=True, + num_conv_branches=1, + ) + self.head = ( + nn.Linear(int(embed_dims[-1] * cls_ratio), num_classes) + if num_classes > 0 + else nn.Identity() + ) + + self.apply(self.cls_init_weights) + self.init_cfg = copy.deepcopy(init_cfg) + + # load pre-trained model + if self.fork_feat and (self.init_cfg is not None or pretrained is not None): + self.init_weights() + + def cls_init_weights(self, m: nn.Module) -> None: + """Init. for classification""" + if isinstance(m, nn.Linear): + trunc_normal_(m.weight, std=0.02) + if isinstance(m, nn.Linear) and m.bias is not None: + nn.init.constant_(m.bias, 0) + + @staticmethod + def _scrub_checkpoint(checkpoint, model): + sterile_dict = {} + for k1, v1 in checkpoint.items(): + if k1 not in model.state_dict(): + continue + if v1.shape == model.state_dict()[k1].shape: + sterile_dict[k1] = v1 + return sterile_dict + + def init_weights(self, pretrained: str = None) -> None: + """Init. for mmdetection or mmsegmentation by loading + ImageNet pre-trained weights. + """ + logger = get_root_logger() + if self.init_cfg is None and pretrained is None: + logger.warning( + f"No pre-trained weights for " + f"{self.__class__.__name__}, " + f"training start from scratch" + ) + pass + else: + assert "checkpoint" in self.init_cfg, ( + f"Only support " + f"specify `Pretrained` in " + f"`init_cfg` in " + f"{self.__class__.__name__} " + ) + if self.init_cfg is not None: + ckpt_path = self.init_cfg["checkpoint"] + elif pretrained is not None: + ckpt_path = pretrained + + ckpt = _load_checkpoint(ckpt_path, logger=logger, map_location="cpu") + if "state_dict" in ckpt: + _state_dict = ckpt["state_dict"] + elif "model" in ckpt: + _state_dict = ckpt["model"] + else: + _state_dict = ckpt + + sterile_dict = FastViT._scrub_checkpoint(_state_dict, self) + state_dict = sterile_dict + missing_keys, unexpected_keys = self.load_state_dict(state_dict, False) + + def forward_embeddings(self, x: torch.Tensor) -> torch.Tensor: + x = self.patch_embed(x) + return x + + def forward_tokens(self, x: torch.Tensor) -> torch.Tensor: + outs = [] + for idx, block in enumerate(self.network): + x = block(x) + if self.fork_feat and idx in self.out_indices: + norm_layer = getattr(self, f"norm{idx}") + x_out = norm_layer(x) + outs.append(x_out) + if self.fork_feat: + # output the features of four stages for dense prediction + return outs + # output only the features of last layer for image classification + return x + + def forward(self, x: torch.Tensor) -> torch.Tensor: + # input embedding + x = self.forward_embeddings(x) + # through backbone + x = self.forward_tokens(x) + if self.fork_feat: + # output features of four stages for dense prediction + return x + # for image classification + x = self.conv_exp(x) + x = self.gap(x) + x = x.view(x.size(0), -1) + cls_out = self.head(x) + return cls_out + + +@register_model +def fastvit_t8(pretrained=False, **kwargs): + """Instantiate FastViT-T8 model variant.""" + layers = [2, 2, 4, 2] + embed_dims = [48, 96, 192, 384] + mlp_ratios = [3, 3, 3, 3] + downsamples = [True, True, True, True] + token_mixers = ("repmixer", "repmixer", "repmixer", "repmixer") + model = FastViT( + layers, + token_mixers=token_mixers, + embed_dims=embed_dims, + mlp_ratios=mlp_ratios, + downsamples=downsamples, + **kwargs, + ) + model.default_cfg = default_cfgs["fastvit_t"] + if pretrained: + raise ValueError("Functionality not implemented.") + return model + + +@register_model +def fastvit_t12(pretrained=False, **kwargs): + """Instantiate FastViT-T12 model variant.""" + layers = [2, 2, 6, 2] + embed_dims = [64, 128, 256, 512] + mlp_ratios = [3, 3, 3, 3] + downsamples = [True, True, True, True] + token_mixers = ("repmixer", "repmixer", "repmixer", "repmixer") + model = FastViT( + layers, + token_mixers=token_mixers, + embed_dims=embed_dims, + mlp_ratios=mlp_ratios, + downsamples=downsamples, + **kwargs, + ) + model.default_cfg = default_cfgs["fastvit_t"] + if pretrained: + raise ValueError("Functionality not implemented.") + return model + + +@register_model +def fastvit_s12(pretrained=False, **kwargs): + """Instantiate FastViT-S12 model variant.""" + layers = [2, 2, 6, 2] + embed_dims = [64, 128, 256, 512] + mlp_ratios = [4, 4, 4, 4] + downsamples = [True, True, True, True] + token_mixers = ("repmixer", "repmixer", "repmixer", "repmixer") + model = FastViT( + layers, + token_mixers=token_mixers, + embed_dims=embed_dims, + mlp_ratios=mlp_ratios, + downsamples=downsamples, + **kwargs, + ) + model.default_cfg = default_cfgs["fastvit_s"] + if pretrained: + raise ValueError("Functionality not implemented.") + return model + + +@register_model +def fastvit_sa12(pretrained=False, **kwargs): + """Instantiate FastViT-SA12 model variant.""" + layers = [2, 2, 6, 2] + embed_dims = [64, 128, 256, 512] + mlp_ratios = [4, 4, 4, 4] + downsamples = [True, True, True, True] + pos_embs = [None, None, None, partial(RepCPE, spatial_shape=(7, 7))] + token_mixers = ("repmixer", "repmixer", "repmixer", "attention") + model = FastViT( + layers, + token_mixers=token_mixers, + embed_dims=embed_dims, + pos_embs=pos_embs, + mlp_ratios=mlp_ratios, + downsamples=downsamples, + **kwargs, + ) + model.default_cfg = default_cfgs["fastvit_s"] + if pretrained: + raise ValueError("Functionality not implemented.") + return model + + +@register_model +def fastvit_sa24(pretrained=False, **kwargs): + """Instantiate FastViT-SA24 model variant.""" + layers = [4, 4, 12, 4] + embed_dims = [64, 128, 256, 512] + mlp_ratios = [4, 4, 4, 4] + downsamples = [True, True, True, True] + pos_embs = [None, None, None, partial(RepCPE, spatial_shape=(7, 7))] + token_mixers = ("repmixer", "repmixer", "repmixer", "attention") + model = FastViT( + layers, + token_mixers=token_mixers, + embed_dims=embed_dims, + pos_embs=pos_embs, + mlp_ratios=mlp_ratios, + downsamples=downsamples, + **kwargs, + ) + model.default_cfg = default_cfgs["fastvit_s"] + if pretrained: + raise ValueError("Functionality not implemented.") + return model + + +@register_model +def fastvit_sa36(pretrained=False, **kwargs): + """Instantiate FastViT-SA36 model variant.""" + layers = [6, 6, 18, 6] + embed_dims = [64, 128, 256, 512] + mlp_ratios = [4, 4, 4, 4] + downsamples = [True, True, True, True] + pos_embs = [None, None, None, partial(RepCPE, spatial_shape=(7, 7))] + token_mixers = ("repmixer", "repmixer", "repmixer", "attention") + model = FastViT( + layers, + embed_dims=embed_dims, + token_mixers=token_mixers, + pos_embs=pos_embs, + mlp_ratios=mlp_ratios, + downsamples=downsamples, + layer_scale_init_value=1e-6, + **kwargs, + ) + model.default_cfg = default_cfgs["fastvit_m"] + if pretrained: + raise ValueError("Functionality not implemented.") + return model + + +@register_model +def fastvit_ma36(pretrained=False, **kwargs): + """Instantiate FastViT-MA36 model variant.""" + layers = [6, 6, 18, 6] + embed_dims = [76, 152, 304, 608] + mlp_ratios = [4, 4, 4, 4] + downsamples = [True, True, True, True] + pos_embs = [None, None, None, partial(RepCPE, spatial_shape=(7, 7))] + token_mixers = ("repmixer", "repmixer", "repmixer", "attention") + model = FastViT( + layers, + embed_dims=embed_dims, + token_mixers=token_mixers, + pos_embs=pos_embs, + mlp_ratios=mlp_ratios, + downsamples=downsamples, + layer_scale_init_value=1e-6, + **kwargs, + ) + model.default_cfg = default_cfgs["fastvit_m"] + if pretrained: + raise ValueError("Functionality not implemented.") + return model diff --git a/src/lightly_train/_models/fastvit/components/models/modules/__init__.py b/src/lightly_train/_models/fastvit/components/models/modules/__init__.py new file mode 100644 index 000000000..80cae297b --- /dev/null +++ b/src/lightly_train/_models/fastvit/components/models/modules/__init__.py @@ -0,0 +1,7 @@ +# +# Copyright (c) Lightly AG and affiliates. +# All rights reserved. +# +# This source code is licensed under the license found in the +# LICENSE file in the root directory of this source tree. +# diff --git a/src/lightly_train/_models/fastvit/components/models/modules/mobileone.py b/src/lightly_train/_models/fastvit/components/models/modules/mobileone.py new file mode 100644 index 000000000..d24dce919 --- /dev/null +++ b/src/lightly_train/_models/fastvit/components/models/modules/mobileone.py @@ -0,0 +1,337 @@ +# +# Copyright (c) Lightly AG and affiliates. +# All rights reserved. +# +# This source code is licensed under the license found in the +# LICENSE file in the root directory of this source tree. +# +import copy +from typing import Tuple, Union + +import torch +import torch.nn as nn +import torch.nn.functional as F + +__all__ = ["MobileOneBlock", "reparameterize_model"] + + +class SEBlock(nn.Module): + """Squeeze and Excite module. + + Pytorch implementation of `Squeeze-and-Excitation Networks` - + https://arxiv.org/pdf/1709.01507.pdf + """ + + def __init__(self, in_channels: int, rd_ratio: float = 0.0625) -> None: + """Construct a Squeeze and Excite Module. + + Args: + in_channels: Number of input channels. + rd_ratio: Input channel reduction ratio. + """ + super(SEBlock, self).__init__() + self.reduce = nn.Conv2d( + in_channels=in_channels, + out_channels=int(in_channels * rd_ratio), + kernel_size=1, + stride=1, + bias=True, + ) + self.expand = nn.Conv2d( + in_channels=int(in_channels * rd_ratio), + out_channels=in_channels, + kernel_size=1, + stride=1, + bias=True, + ) + + def forward(self, inputs: torch.Tensor) -> torch.Tensor: + """Apply forward pass.""" + b, c, h, w = inputs.size() + x = F.avg_pool2d(inputs, kernel_size=[h, w]) + x = self.reduce(x) + x = F.relu(x) + x = self.expand(x) + x = torch.sigmoid(x) + x = x.view(-1, c, 1, 1) + return inputs * x + + +class MobileOneBlock(nn.Module): + """MobileOne building block. + + This block has a multi-branched architecture at train-time + and plain-CNN style architecture at inference time + For more details, please refer to our paper: + `An Improved One millisecond Mobile Backbone` - + https://arxiv.org/pdf/2206.04040.pdf + """ + + def __init__( + self, + in_channels: int, + out_channels: int, + kernel_size: int, + stride: int = 1, + padding: int = 0, + dilation: int = 1, + groups: int = 1, + inference_mode: bool = False, + use_se: bool = False, + use_act: bool = True, + use_scale_branch: bool = True, + num_conv_branches: int = 1, + activation: nn.Module = nn.GELU(), + ) -> None: + """Construct a MobileOneBlock module. + + Args: + in_channels: Number of channels in the input. + out_channels: Number of channels produced by the block. + kernel_size: Size of the convolution kernel. + stride: Stride size. + padding: Zero-padding size. + dilation: Kernel dilation factor. + groups: Group number. + inference_mode: If True, instantiates model in inference mode. + use_se: Whether to use SE-ReLU activations. + use_act: Whether to use activation. Default: ``True`` + use_scale_branch: Whether to use scale branch. Default: ``True`` + num_conv_branches: Number of linear conv branches. + """ + super(MobileOneBlock, self).__init__() + self.inference_mode = inference_mode + self.groups = groups + self.stride = stride + self.padding = padding + self.dilation = dilation + self.kernel_size = kernel_size + self.in_channels = in_channels + self.out_channels = out_channels + self.num_conv_branches = num_conv_branches + + # Check if SE-ReLU is requested + if use_se: + self.se = SEBlock(out_channels) + else: + self.se = nn.Identity() + + if use_act: + self.activation = activation + else: + self.activation = nn.Identity() + + if inference_mode: + self.reparam_conv = nn.Conv2d( + in_channels=in_channels, + out_channels=out_channels, + kernel_size=kernel_size, + stride=stride, + padding=padding, + dilation=dilation, + groups=groups, + bias=True, + ) + else: + # Re-parameterizable skip connection + self.rbr_skip = ( + nn.BatchNorm2d(num_features=in_channels) + if out_channels == in_channels and stride == 1 + else None + ) + + # Re-parameterizable conv branches + if num_conv_branches > 0: + rbr_conv = list() + for _ in range(self.num_conv_branches): + rbr_conv.append( + self._conv_bn(kernel_size=kernel_size, padding=padding) + ) + self.rbr_conv = nn.ModuleList(rbr_conv) + else: + self.rbr_conv = None + + # Re-parameterizable scale branch + self.rbr_scale = None + if (kernel_size > 1) and use_scale_branch: + self.rbr_scale = self._conv_bn(kernel_size=1, padding=0) + + def forward(self, x: torch.Tensor) -> torch.Tensor: + """Apply forward pass.""" + # Inference mode forward pass. + if self.inference_mode: + return self.activation(self.se(self.reparam_conv(x))) + + # Multi-branched train-time forward pass. + # Skip branch output + identity_out = 0 + if self.rbr_skip is not None: + identity_out = self.rbr_skip(x) + + # Scale branch output + scale_out = 0 + if self.rbr_scale is not None: + scale_out = self.rbr_scale(x) + + # Other branches + out = scale_out + identity_out + if self.rbr_conv is not None: + for ix in range(self.num_conv_branches): + out += self.rbr_conv[ix](x) + + return self.activation(self.se(out)) + + def reparameterize(self): + """Following works like `RepVGG: Making VGG-style ConvNets Great Again` - + https://arxiv.org/pdf/2101.03697.pdf. We re-parameterize multi-branched + architecture used at training time to obtain a plain CNN-like structure + for inference. + """ + if self.inference_mode: + return + kernel, bias = self._get_kernel_bias() + self.reparam_conv = nn.Conv2d( + in_channels=self.in_channels, + out_channels=self.out_channels, + kernel_size=self.kernel_size, + stride=self.stride, + padding=self.padding, + dilation=self.dilation, + groups=self.groups, + bias=True, + ) + self.reparam_conv.weight.data = kernel + self.reparam_conv.bias.data = bias + + # Delete un-used branches + for para in self.parameters(): + para.detach_() + self.__delattr__("rbr_conv") + self.__delattr__("rbr_scale") + if hasattr(self, "rbr_skip"): + self.__delattr__("rbr_skip") + + self.inference_mode = True + + def _get_kernel_bias(self) -> Tuple[torch.Tensor, torch.Tensor]: + """Method to obtain re-parameterized kernel and bias. + Reference: https://github.com/DingXiaoH/RepVGG/blob/main/repvgg.py#L83 + + Returns: + Tuple of (kernel, bias) after fusing branches. + """ + # get weights and bias of scale branch + kernel_scale = 0 + bias_scale = 0 + if self.rbr_scale is not None: + kernel_scale, bias_scale = self._fuse_bn_tensor(self.rbr_scale) + # Pad scale branch kernel to match conv branch kernel size. + pad = self.kernel_size // 2 + kernel_scale = torch.nn.functional.pad(kernel_scale, [pad, pad, pad, pad]) + + # get weights and bias of skip branch + kernel_identity = 0 + bias_identity = 0 + if self.rbr_skip is not None: + kernel_identity, bias_identity = self._fuse_bn_tensor(self.rbr_skip) + + # get weights and bias of conv branches + kernel_conv = 0 + bias_conv = 0 + if self.rbr_conv is not None: + for ix in range(self.num_conv_branches): + _kernel, _bias = self._fuse_bn_tensor(self.rbr_conv[ix]) + kernel_conv += _kernel + bias_conv += _bias + + kernel_final = kernel_conv + kernel_scale + kernel_identity + bias_final = bias_conv + bias_scale + bias_identity + return kernel_final, bias_final + + def _fuse_bn_tensor( + self, branch: Union[nn.Sequential, nn.BatchNorm2d] + ) -> Tuple[torch.Tensor, torch.Tensor]: + """Method to fuse batchnorm layer with preceeding conv layer. + Reference: https://github.com/DingXiaoH/RepVGG/blob/main/repvgg.py#L95 + + Args: + branch: Sequence of ops to be fused. + + Returns: + Tuple of (kernel, bias) after fusing batchnorm. + """ + if isinstance(branch, nn.Sequential): + kernel = branch.conv.weight + running_mean = branch.bn.running_mean + running_var = branch.bn.running_var + gamma = branch.bn.weight + beta = branch.bn.bias + eps = branch.bn.eps + else: + assert isinstance(branch, nn.BatchNorm2d) + if not hasattr(self, "id_tensor"): + input_dim = self.in_channels // self.groups + kernel_value = torch.zeros( + (self.in_channels, input_dim, self.kernel_size, self.kernel_size), + dtype=branch.weight.dtype, + device=branch.weight.device, + ) + for i in range(self.in_channels): + kernel_value[ + i, i % input_dim, self.kernel_size // 2, self.kernel_size // 2 + ] = 1 + self.id_tensor = kernel_value + kernel = self.id_tensor + running_mean = branch.running_mean + running_var = branch.running_var + gamma = branch.weight + beta = branch.bias + eps = branch.eps + std = (running_var + eps).sqrt() + t = (gamma / std).reshape(-1, 1, 1, 1) + return kernel * t, beta - running_mean * gamma / std + + def _conv_bn(self, kernel_size: int, padding: int) -> nn.Sequential: + """Helper method to construct conv-batchnorm layers. + + Args: + kernel_size: Size of the convolution kernel. + padding: Zero-padding size. + + Returns: + Conv-BN module. + """ + mod_list = nn.Sequential() + mod_list.add_module( + "conv", + nn.Conv2d( + in_channels=self.in_channels, + out_channels=self.out_channels, + kernel_size=kernel_size, + stride=self.stride, + padding=padding, + groups=self.groups, + bias=False, + ), + ) + mod_list.add_module("bn", nn.BatchNorm2d(num_features=self.out_channels)) + return mod_list + + +def reparameterize_model(model: torch.nn.Module) -> nn.Module: + """Method returns a model where a multi-branched structure + used in training is re-parameterized into a single branch + for inference. + + Args: + model: MobileOne model in train mode. + + Returns: + MobileOne model in inference mode. + """ + # Avoid editing original graph + model = copy.deepcopy(model) + for module in model.modules(): + if hasattr(module, "reparameterize"): + module.reparameterize() + return model diff --git a/src/lightly_train/_models/fastvit/components/models/modules/replknet.py b/src/lightly_train/_models/fastvit/components/models/modules/replknet.py new file mode 100644 index 000000000..6bf933b7f --- /dev/null +++ b/src/lightly_train/_models/fastvit/components/models/modules/replknet.py @@ -0,0 +1,182 @@ +# +# Copyright (c) Lightly AG and affiliates. +# All rights reserved. +# +# This source code is licensed under the license found in the +# LICENSE file in the root directory of this source tree. +# +from typing import Tuple + +import torch +import torch.nn as nn + +__all__ = ["ReparamLargeKernelConv"] + + +class ReparamLargeKernelConv(nn.Module): + """Building Block of RepLKNet + + This class defines overparameterized large kernel conv block + introduced in `RepLKNet `_ + + Reference: https://github.com/DingXiaoH/RepLKNet-pytorch + """ + + def __init__( + self, + in_channels: int, + out_channels: int, + kernel_size: int, + stride: int, + groups: int, + small_kernel: int, + inference_mode: bool = False, + activation: nn.Module = nn.GELU(), + ) -> None: + """Construct a ReparamLargeKernelConv module. + + Args: + in_channels: Number of input channels. + out_channels: Number of output channels. + kernel_size: Kernel size of the large kernel conv branch. + stride: Stride size. Default: 1 + groups: Group number. Default: 1 + small_kernel: Kernel size of small kernel conv branch. + inference_mode: If True, instantiates model in inference mode. Default: ``False`` + activation: Activation module. Default: ``nn.GELU`` + """ + super(ReparamLargeKernelConv, self).__init__() + + self.stride = stride + self.groups = groups + self.in_channels = in_channels + self.out_channels = out_channels + self.activation = activation + + self.kernel_size = kernel_size + self.small_kernel = small_kernel + self.padding = kernel_size // 2 + if inference_mode: + self.lkb_reparam = nn.Conv2d( + in_channels=in_channels, + out_channels=out_channels, + kernel_size=kernel_size, + stride=stride, + padding=self.padding, + dilation=1, + groups=groups, + bias=True, + ) + else: + self.lkb_origin = self._conv_bn( + kernel_size=kernel_size, padding=self.padding + ) + if small_kernel is not None: + assert small_kernel <= kernel_size, ( + "The kernel size for re-param cannot be larger than the large kernel!" + ) + self.small_conv = self._conv_bn( + kernel_size=small_kernel, padding=small_kernel // 2 + ) + + def forward(self, x: torch.Tensor) -> torch.Tensor: + """Apply forward pass.""" + if hasattr(self, "lkb_reparam"): + out = self.lkb_reparam(x) + else: + out = self.lkb_origin(x) + if hasattr(self, "small_conv"): + out += self.small_conv(x) + + self.activation(out) + return out + + def get_kernel_bias(self) -> Tuple[torch.Tensor, torch.Tensor]: + """Method to obtain re-parameterized kernel and bias. + Reference: https://github.com/DingXiaoH/RepLKNet-pytorch + + Returns: + Tuple of (kernel, bias) after fusing branches. + """ + eq_k, eq_b = self._fuse_bn(self.lkb_origin.conv, self.lkb_origin.bn) + if hasattr(self, "small_conv"): + small_k, small_b = self._fuse_bn(self.small_conv.conv, self.small_conv.bn) + eq_b += small_b + eq_k += nn.functional.pad( + small_k, [(self.kernel_size - self.small_kernel) // 2] * 4 + ) + return eq_k, eq_b + + def reparameterize(self) -> None: + """ + Following works like `RepVGG: Making VGG-style ConvNets Great Again` - + https://arxiv.org/pdf/2101.03697.pdf. We re-parameterize multi-branched + architecture used at training time to obtain a plain CNN-like structure + for inference. + """ + eq_k, eq_b = self.get_kernel_bias() + self.lkb_reparam = nn.Conv2d( + in_channels=self.in_channels, + out_channels=self.out_channels, + kernel_size=self.kernel_size, + stride=self.stride, + padding=self.padding, + dilation=self.lkb_origin.conv.dilation, + groups=self.groups, + bias=True, + ) + + self.lkb_reparam.weight.data = eq_k + self.lkb_reparam.bias.data = eq_b + self.__delattr__("lkb_origin") + if hasattr(self, "small_conv"): + self.__delattr__("small_conv") + + @staticmethod + def _fuse_bn( + conv: torch.Tensor, bn: nn.BatchNorm2d + ) -> Tuple[torch.Tensor, torch.Tensor]: + """Method to fuse batchnorm layer with conv layer. + + Args: + conv: Convolutional kernel weights. + bn: Batchnorm 2d layer. + + Returns: + Tuple of (kernel, bias) after fusing batchnorm. + """ + kernel = conv.weight + running_mean = bn.running_mean + running_var = bn.running_var + gamma = bn.weight + beta = bn.bias + eps = bn.eps + std = (running_var + eps).sqrt() + t = (gamma / std).reshape(-1, 1, 1, 1) + return kernel * t, beta - running_mean * gamma / std + + def _conv_bn(self, kernel_size: int, padding: int = 0) -> nn.Sequential: + """Helper method to construct conv-batchnorm layers. + + Args: + kernel_size: Size of the convolution kernel. + padding: Zero-padding size. + + Returns: + A nn.Sequential Conv-BN module. + """ + mod_list = nn.Sequential() + mod_list.add_module( + "conv", + nn.Conv2d( + in_channels=self.in_channels, + out_channels=self.out_channels, + kernel_size=kernel_size, + stride=self.stride, + padding=padding, + groups=self.groups, + bias=False, + ), + ) + mod_list.add_module("bn", nn.BatchNorm2d(num_features=self.out_channels)) + return mod_list diff --git a/src/lightly_train/_models/fastvit/fastvit.py b/src/lightly_train/_models/fastvit/fastvit.py new file mode 100644 index 000000000..0704dff6f --- /dev/null +++ b/src/lightly_train/_models/fastvit/fastvit.py @@ -0,0 +1,148 @@ +# +# Copyright (c) Lightly AG and affiliates. +# All rights reserved. +# +# This source code is licensed under the license found in the +# LICENSE file in the root directory of this source tree. +# +from __future__ import annotations + +import logging +from typing import Sequence + +import torch +from torch import Tensor +from torch.nn import Module + +from lightly_train._models.model_wrapper import ( + ArchitectureInfo, + ArchitectureInfoGettable, + ForwardFeaturesOutput, + ForwardPoolOutput, + MultiScaleFeatureCNN, +) + +logger = logging.getLogger(__name__) + +# Network indices that correspond to the end of each stage in FastViT's +# self.network ModuleList. The network alternates [stage_blocks, downsample, ...] +# so stage 0 ends at index 0, stage 1 at 2, stage 2 at 4, stage 3 at 6. +_FASTVIT_STAGE_INDICES = [0, 2, 4, 6] + + +class FastViTModelWrapper(Module, MultiScaleFeatureCNN, ArchitectureInfoGettable): + def __init__(self, model: Module) -> None: + for attr in ("forward_embeddings", "forward_tokens", "conv_exp", "gap"): + if not hasattr(model, attr): + raise ValueError(f"Model must have a '{attr}' attribute") + super().__init__() + self._model = model + self._cached_feature_dims: list[int] | None = None + self._cached_feature_strides: list[int] | None = None + self._cached_pooled_dim: int | None = None + + def feature_dim(self) -> int: + if self._cached_pooled_dim is not None: + return self._cached_pooled_dim + was_training = self._model.training + self._model.eval() + try: + with torch.no_grad(): + x = torch.randn(1, 3, 64, 64) + out = self.forward_features(x) + pooled = self.forward_pool(out) + self._cached_pooled_dim = pooled["pooled_features"].flatten(1).shape[1] + finally: + if was_training: + self._model.train() + return self._cached_pooled_dim + + def forward_features(self, x: Tensor) -> ForwardFeaturesOutput: + x = self._model.forward_embeddings(x) # type: ignore[operator] + x = self._model.forward_tokens(x) # type: ignore[operator] + x = self._model.conv_exp(x) # type: ignore[operator] + return {"features": x} + + def forward_pool(self, x: ForwardFeaturesOutput) -> ForwardPoolOutput: + features: Tensor = self._model.gap(x["features"]) # type: ignore[operator] + return {"pooled_features": features} + + def get_model(self) -> Module: + return self._model + + def architecture_info(self) -> ArchitectureInfo: + return {"model_type": "hybrid", "norm_type": "batchnorm"} # type: ignore[return-value] + + def multiscale_feature_dims(self) -> list[int]: + if self._cached_feature_dims is not None: + return self._cached_feature_dims + was_training = self._model.training + self._model.eval() + try: + with torch.no_grad(): + x = torch.randn(1, 3, 64, 64) + x = self._model.forward_embeddings(x) # type: ignore[operator] + dims: list[int] = [] + net_idx = 0 + for net_end_idx in _FASTVIT_STAGE_INDICES: + while net_idx <= net_end_idx: + x = self._model.network[net_idx](x) # type: ignore[operator, index] + net_idx += 1 + dims.append(x.shape[1]) + finally: + if was_training: + self._model.train() + self._cached_feature_dims = dims + return dims + + def multiscale_feature_strides(self) -> list[int]: + if self._cached_feature_strides is not None: + return self._cached_feature_strides + was_training = self._model.training + self._model.eval() + try: + with torch.no_grad(): + h_in, w_in = 64, 64 + x = torch.randn(1, 3, h_in, w_in) + x = self._model.forward_embeddings(x) # type: ignore[operator] + strides: list[int] = [] + net_idx = 0 + for net_end_idx in _FASTVIT_STAGE_INDICES: + while net_idx <= net_end_idx: + x = self._model.network[net_idx](x) # type: ignore[operator, index] + net_idx += 1 + out_h = x.shape[-2] + strides.append(h_in // out_h) + finally: + if was_training: + self._model.train() + self._cached_feature_strides = strides + return strides + + def forward_multiscale_features( + self, x: Tensor, layer_indices: Sequence[int] + ) -> list[ForwardFeaturesOutput]: + requested = set(layer_indices) + assert requested.issubset(set(range(len(_FASTVIT_STAGE_INDICES)))), ( + f"layer_indices must be in [0, {len(_FASTVIT_STAGE_INDICES) - 1}], " + f"got {list(requested)}" + ) + + x = self._model.forward_embeddings(x) # type: ignore[operator] + results: dict[int, Tensor] = {} + net_idx = 0 + for stage_idx, net_end_idx in enumerate(_FASTVIT_STAGE_INDICES): + while net_idx <= net_end_idx: + x = self._model.network[net_idx](x) # type: ignore[operator, index] + net_idx += 1 + if stage_idx in requested: + # Apply per-stage norm if available (when fork_feat is enabled). + norm_name = f"norm{_FASTVIT_STAGE_INDICES[stage_idx]}" + if hasattr(self._model, norm_name): + norm = getattr(self._model, norm_name) + x_stage = norm(x) + else: + x_stage = x + results[stage_idx] = x_stage + + return [{"features": results[idx]} for idx in layer_indices] diff --git a/src/lightly_train/_models/fastvit/fastvit_package.py b/src/lightly_train/_models/fastvit/fastvit_package.py new file mode 100644 index 000000000..161446d4e --- /dev/null +++ b/src/lightly_train/_models/fastvit/fastvit_package.py @@ -0,0 +1,132 @@ +# +# Copyright (c) Lightly AG and affiliates. +# All rights reserved. +# +# This source code is licensed under the license found in the +# LICENSE file in the root directory of this source tree. +# +from __future__ import annotations + +import logging +from pathlib import Path +from typing import Any + +import torch +from torch.nn import Module + +from lightly_train._models.fastvit.fastvit import FastViTModelWrapper +from lightly_train._models.model_wrapper import ModelWrapper +from lightly_train._models.package import Package + +logger = logging.getLogger(__name__) + +_FASTVIT_MODEL_NAMES = [ + "fastvit_t8", + "fastvit_t12", + "fastvit_s12", + "fastvit_sa12", + "fastvit_sa24", + "fastvit_sa36", + "fastvit_ma36", +] + + +def _get_model_factory() -> dict[str, Any]: + from lightly_train._models.fastvit.components.models.fastvit import ( + fastvit_ma36, + fastvit_s12, + fastvit_sa12, + fastvit_sa24, + fastvit_sa36, + fastvit_t8, + fastvit_t12, + ) + + return { + "fastvit_t8": fastvit_t8, + "fastvit_t12": fastvit_t12, + "fastvit_s12": fastvit_s12, + "fastvit_sa12": fastvit_sa12, + "fastvit_sa24": fastvit_sa24, + "fastvit_sa36": fastvit_sa36, + "fastvit_ma36": fastvit_ma36, + } + + +class FastViTPackage(Package): + name = "fastvit" + + @classmethod + def list_model_names(cls) -> list[str]: + return [f"{cls.name}/{n}" for n in _FASTVIT_MODEL_NAMES] + + @classmethod + def is_supported_model(cls, model: Module | ModelWrapper | Any) -> bool: + if isinstance(model, ModelWrapper): + model = model.get_model() + try: + from lightly_train._models.fastvit.components.models.fastvit import FastViT + + return isinstance(model, FastViT) + except ImportError: + return False + + @classmethod + def get_model( + cls, + model_name: str, + num_input_channels: int = 3, + model_args: dict[str, Any] | None = None, + load_weights: bool = True, + ) -> Module: + if num_input_channels != 3: + raise ValueError( + f"FastViT only supports 3 input channels, but got {num_input_channels}. " + "The convolutional stem is hardcoded to 3 input channels." + ) + if load_weights: + logger.warning( + "FastViT does not provide pretrained weights in this integration. " + "The model will be initialized with random weights." + ) + factory = _get_model_factory() + if model_name not in factory: + raise ValueError( + f"Unknown FastViT model name: '{model_name}'. " + f"Supported models: {list(factory)}." + ) + args: dict[str, Any] = model_args or {} + model: Module = factory[model_name](pretrained=False, **args) + return model + + @classmethod + def get_model_wrapper(cls, model: Module) -> FastViTModelWrapper: + return FastViTModelWrapper(model) + + @classmethod + def export_model( + cls, model: Module | ModelWrapper | Any, out: Path, log_example: bool = True + ) -> None: + if isinstance(model, ModelWrapper): + model = model.get_model() + + if not cls.is_supported_model(model): + raise ValueError( + "FastViTPackage only supports exporting FastViT models, " + f"but received '{type(model)}'." + ) + + torch.save(model.state_dict(), out) + + if log_example: + logger.warning( + "Usage example cannot be constructed for FastViT models: " + "model name cannot be recovered from the model instance. " + "Load the exported weights manually with the factory function " + f"and model.load_state_dict(torch.load('{out}'))." + ) + + +# Create singleton instance of the package. The singleton should be used whenever +# possible. +FASTVIT_PACKAGE = FastViTPackage() diff --git a/src/lightly_train/_models/model_wrapper.py b/src/lightly_train/_models/model_wrapper.py index f9c42ad95..5ebcb003b 100644 --- a/src/lightly_train/_models/model_wrapper.py +++ b/src/lightly_train/_models/model_wrapper.py @@ -128,6 +128,8 @@ def eval(self) -> Self: ... def modules(self) -> Iterator[Module]: ... + def requires_grad_(self, requires_grad: bool = True) -> Self: ... + @runtime_checkable class ModelWrapper( @@ -140,7 +142,8 @@ class ModelWrapper( ): ... -class MultiScaleFeatureDim(Protocol): +@runtime_checkable +class MultiScaleFeatureDims(Protocol): def multiscale_feature_dims(self) -> list[int]: """Returns the feature dimensions of each layer/stage in the model. @@ -156,7 +159,33 @@ def multiscale_feature_dims(self) -> list[int]: @runtime_checkable -class MultiScaleFeatureModelWrapper(ModelWrapper, MultiScaleFeatureDim, Protocol): +class PatchSize(Protocol): + def patch_size(self) -> int: + """Returns the patch size of the model. + + For ViT models this is the size of each patch (e.g., 16 or 14). + """ + ... + + +@runtime_checkable +class MultiScaleFeatureStrides(Protocol): + def multiscale_feature_strides(self) -> list[int]: + """Returns the feature strides of each layer/stage in the model. + + The returned list has one entry per layer/stage, indexed from 0 (earliest + layer/stage) to N-1 (last layer/stage). For a ViT all entries are typically + the same (equal to the patch size). For a ConvNeXt each stage has a different + stride (e.g. [4, 8, 16, 32] for a model with patch size 4). + + The index of each entry corresponds to the layer indices accepted by + ``forward_multiscale_features``. + """ + ... + + +@runtime_checkable +class ForwardMultiScaleFeatures(Protocol): def forward_multiscale_features( self, x: Tensor, layer_indices: Sequence[int] ) -> list[ForwardFeaturesOutput]: @@ -181,6 +210,22 @@ def forward_multiscale_features( ... +class MultiScaleFeatureViT( + ModelWrapper, ForwardMultiScaleFeatures, MultiScaleFeatureDims, PatchSize, Protocol +): + """Protocol for ViT models with multiscale feature extraction.""" + + +class MultiScaleFeatureCNN( + ModelWrapper, + ForwardMultiScaleFeatures, + MultiScaleFeatureDims, + MultiScaleFeatureStrides, + Protocol, +): + """Protocol for CNN models with multiscale feature extraction.""" + + def missing_model_wrapper_attrs( model_wrapper: Any, exclude_module_attrs: bool = False ) -> list[str]: diff --git a/src/lightly_train/_models/package_helpers.py b/src/lightly_train/_models/package_helpers.py index 86a5a536e..ce90f81a9 100644 --- a/src/lightly_train/_models/package_helpers.py +++ b/src/lightly_train/_models/package_helpers.py @@ -16,6 +16,7 @@ from lightly_train._models.custom.custom_package import CUSTOM_PACKAGE from lightly_train._models.dinov2_vit.dinov2_vit_package import DINOV2_VIT_PACKAGE from lightly_train._models.dinov3.dinov3_package import DINOV3_PACKAGE +from lightly_train._models.fastvit.fastvit_package import FASTVIT_PACKAGE from lightly_train._models.model_wrapper import ModelWrapper from lightly_train._models.package import BasePackage, Package from lightly_train._models.rfdetr.rfdetr_package import RFDETR_PACKAGE @@ -31,6 +32,7 @@ def list_base_packages() -> list[BasePackage]: """Lists all supported packages.""" return [ + FASTVIT_PACKAGE, RFDETR_PACKAGE, SUPER_GRADIENTS_PACKAGE, TIMM_PACKAGE, diff --git a/src/lightly_train/_task_models/dinov2_linear_semantic_segmentation/task_model.py b/src/lightly_train/_task_models/dinov2_linear_semantic_segmentation/task_model.py index 6a48594f9..cc4ce2d6f 100644 --- a/src/lightly_train/_task_models/dinov2_linear_semantic_segmentation/task_model.py +++ b/src/lightly_train/_task_models/dinov2_linear_semantic_segmentation/task_model.py @@ -23,9 +23,7 @@ from lightly_train._data import file_helpers from lightly_train._models import package_helpers from lightly_train._models.dinov2_vit.dinov2_vit_package import DINOV2_VIT_PACKAGE -from lightly_train._models.dinov2_vit.dinov2_vit_src.models.vision_transformer import ( - DinoVisionTransformer, -) +from lightly_train._models.model_wrapper import ModelWrapper from lightly_train._task_models.task_model import TaskModel from lightly_train.types import PathLike @@ -65,10 +63,10 @@ def __init__( image_normalize: The normalization parameters for images. Default uses ImageNet stats. backbone_weights: - The path to the DINOv2 backbone weights. The weights must be exported + The path to the backbone weights. The weights must be exported using LightlyTrain. backbone_args: - Additional arguments to pass to the DINOv2 backbone. + Additional arguments to pass to the backbone. load_weights: If False, then no pretrained weights are loaded. """ @@ -108,27 +106,36 @@ def __init__( if self.class_ignore_index is not None: self.included_classes[self.class_ignore_index] = "ignored" - # Disable drop path by default. - args = { - "drop_path_rate": 0.0, - "in_chans": len(self.image_normalize["mean"]), - } + # Disable drop path by default for DINOv2. + args: dict[str, Any] = {} + if parsed_name["package_name"] == DINOV2_VIT_PACKAGE.name: + args["drop_path_rate"] = 0.0 if backbone_args is not None: args.update(backbone_args) - - # Get the backbone. - self.backbone: DinoVisionTransformer = DINOV2_VIT_PACKAGE.get_model( - model_name=parsed_name["backbone_name"], + # Non-DINOv2 builders (e.g. DINOv3) hardcode drop_path_rate internally; + # passing it again causes a duplicate keyword argument error. + if parsed_name["package_name"] != DINOV2_VIT_PACKAGE.name: + args.pop("drop_path_rate", None) + + # Build the backbone via the package registry. + num_channels = len(self.image_normalize["mean"]) + self.backbone: ModelWrapper = package_helpers.get_wrapped_model( + model=f"{parsed_name['package_name']}/{parsed_name['backbone_name']}", + num_input_channels=num_channels, model_args=args, load_weights=load_weights, ) - embed_dim = self.backbone.embed_dim - self.patch_size = self.backbone.patch_size + embed_dim = self.backbone.feature_dim() + + # patch_size is only available on ViT backbones. + underlying = self.backbone.get_model() + self.patch_size: int | None = getattr(underlying, "patch_size", None) # TODO(Guarin, 07/25): Improve how mask tokens are handled for fine-tuning. # Should we drop them from the model? We disable grads here for DDP to work # without find_unused_parameters=True. - self.backbone.mask_token.requires_grad = False + if hasattr(underlying, "mask_token"): + underlying.mask_token.requires_grad = False # Load the backbone weights if a path is provided. # TODO(Thomas,07/2026): this should be done in the package. @@ -144,7 +151,8 @@ def __init__( def list_model_names(cls) -> list[str]: return [ f"{name}-{cls.model_suffix}" - for name in DINOV2_VIT_PACKAGE.list_model_names() + for pkg in package_helpers.list_packages() + for name in pkg.list_model_names() ] @classmethod @@ -176,19 +184,22 @@ def raise_invalid_name() -> None: except ValueError: raise_invalid_name() - if package_name != DINOV2_VIT_PACKAGE.name: - raise_invalid_name() - try: - backbone_name = DINOV2_VIT_PACKAGE.parse_model_name( - model_name=backbone_name - ) + package = package_helpers.get_package(package_name) except ValueError: raise_invalid_name() + # Canonicalize the backbone name if the package supports it. + if hasattr(package, "parse_model_name"): + try: + backbone_name = package.parse_model_name(model_name=backbone_name) + except (ValueError, KeyError): + raise_invalid_name() + return { - "model_name": f"{DINOV2_VIT_PACKAGE.name}/{backbone_name}-{cls.model_suffix}", + "model_name": f"{package_name}/{backbone_name}-{cls.model_suffix}", "backbone_name": backbone_name, + "package_name": package_name, } @torch.no_grad() @@ -343,18 +354,15 @@ def forward(self, x: Tensor) -> tuple[Tensor, Tensor]: return masks, logits def forward_train(self, x: Tensor) -> Tensor: - B, _, H, W = x.shape + _, _, H, W = x.shape - # Get the patch tokens -> (B, N, D) where N = H_patch * W_patch. - patch_tokens = self.backbone(x, is_training=True)["x_norm_patchtokens"] + # Get the patch tokens -> (B, D, H_patch, W_patch). + features = self.backbone.forward_features(x)["features"] - # Classify the patch tokens -> (B, N, K|K+1), K=num_classes - logits: Tensor = self.head(patch_tokens) - - # Reshape back to (B, K|K+1, H_patch, W_patch). - H_patch = math.ceil(H / self.patch_size) - W_patch = math.ceil(W / self.patch_size) - logits = logits.permute(0, 2, 1).reshape(B, -1, H_patch, W_patch) + # Classify the patch tokens -> (B, K|K+1, H_patch, W_patch), K=num_classes. + features = features.permute(0, 2, 3, 1) # (B, H_patch, W_patch, D) + logits: Tensor = self.head(features) # (B, H_patch, W_patch, K|K+1) + logits = logits.permute(0, 3, 1, 2) # (B, K|K+1, H_patch, W_patch) # Up-sample to match original image/mask resolution. # (B, K|K+1, H, W) @@ -474,7 +482,9 @@ def load_backbone_weights(self, path: PathLike) -> None: state_dict = torch.load(path, map_location="cpu", weights_only=False) # Load the state dict into the backbone. - missing, unexpected = self.backbone.load_state_dict(state_dict, strict=False) + missing, unexpected = self.backbone.get_model().load_state_dict( + state_dict, strict=False + ) # Log missing and unexpected keys. if missing or unexpected: @@ -495,5 +505,5 @@ def load_train_state_dict(self, state_dict: dict[str, Any]) -> None: self.load_state_dict(new_state_dict, strict=True) def freeze_backbone(self) -> None: - self.backbone.eval() - self.backbone.requires_grad_(False) + self.backbone.eval() # type: ignore[attr-defined] + self.backbone.requires_grad_(False) # type: ignore[attr-defined] diff --git a/src/lightly_train/_task_models/dinov2_ltdetr_object_detection/task_model.py b/src/lightly_train/_task_models/dinov2_ltdetr_object_detection/task_model.py deleted file mode 100644 index 5ef4bac2e..000000000 --- a/src/lightly_train/_task_models/dinov2_ltdetr_object_detection/task_model.py +++ /dev/null @@ -1,1072 +0,0 @@ -# -# Copyright (c) Lightly AG and affiliates. -# All rights reserved. -# -# This source code is licensed under the license found in the -# LICENSE file in the root directory of this source tree. -# -from __future__ import annotations - -import logging -from collections.abc import Sequence -from pathlib import Path -from typing import Any, Literal - -import torch -from PIL.Image import Image as PILImage -from pydantic import Field -from torch import Tensor -from torch.nn import Module -from torchvision.transforms.v2 import functional as transforms_functional -from typing_extensions import Self - -from lightly_train._configs.config import PydanticConfig -from lightly_train._data import file_helpers -from lightly_train._models import package_helpers -from lightly_train._models.dinov2_vit.dinov2_vit import DINOv2ViTModelWrapper -from lightly_train._models.dinov2_vit.dinov2_vit_package import DINOV2_VIT_PACKAGE -from lightly_train._task_models.dinov2_ltdetr_object_detection.dinov2_vit_wrapper import ( - DINOv2STAs, -) -from lightly_train._task_models.object_detection_components import tiling_utils -from lightly_train._task_models.object_detection_components.dfine_decoder import ( - DFINETransformer, -) -from lightly_train._task_models.object_detection_components.hybrid_encoder import ( - HybridEncoder, -) -from lightly_train._task_models.object_detection_components.rtdetr_postprocessor import ( - RTDETRPostProcessor, -) -from lightly_train._task_models.object_detection_components.rtdetrv2_decoder import ( - RTDETRTransformerv2, -) -from lightly_train._task_models.task_model import TaskModel -from lightly_train.types import PathLike - -logger = logging.getLogger(__name__) - -_LTDETRDecoderName = Literal["rtdetrv2", "dfine"] - - -class _HybridEncoderConfig(PydanticConfig): - in_channels: list[int] - feat_strides: list[int] - hidden_dim: int - use_encoder_idx: list[int] - num_encoder_layers: int - nhead: int - dim_feedforward: int - dropout: float - enc_act: str - expansion: float - depth_mult: float - act: str - upsample: bool = True - - -class _HybridEncoderViTTestConfig(_HybridEncoderConfig): - in_channels: list[int] = [224, 224, 224] - feat_strides: list[int] = [7, 14, 28] - hidden_dim: int = 224 - use_encoder_idx: list[int] = [1] - num_encoder_layers: int = 1 - nhead: int = 1 - dim_feedforward: int = 224 - dropout: float = 0.0 - enc_act: str = "gelu" - expansion: float = 1.0 - depth_mult: float = 1.0 - act: str = "silu" - - -class _HybridEncoderViTSConfig(_HybridEncoderConfig): - in_channels: list[int] = [224, 224, 224] - feat_strides: list[int] = [7, 14, 28] - hidden_dim: int = 224 - use_encoder_idx: list[int] = [2] - num_encoder_layers: int = 1 - nhead: int = 8 - dim_feedforward: int = 896 - dropout: float = 0.0 - enc_act: str = "gelu" - expansion: float = 1.0 - depth_mult: float = 1.0 - act: str = "silu" - - -class _HybridEncoderViTBConfig(_HybridEncoderConfig): - in_channels: list[int] = [768, 768, 768] - feat_strides: list[int] = [7, 14, 28] - hidden_dim: int = 768 - use_encoder_idx: list[int] = [2] - num_encoder_layers: int = 1 - nhead: int = 8 - dim_feedforward: int = 3072 - dropout: float = 0.0 - enc_act: str = "gelu" - expansion: float = 1.0 - depth_mult: float = 1.0 - act: str = "silu" - - -class _HybridEncoderViTLConfig(_HybridEncoderConfig): - in_channels: list[int] = [1024, 1024, 1024] - feat_strides: list[int] = [7, 14, 28] - hidden_dim: int = 1024 - use_encoder_idx: list[int] = [2] - num_encoder_layers: int = 1 - nhead: int = 8 - dim_feedforward: int = 4096 - dropout: float = 0.0 - enc_act: str = "gelu" - expansion: float = 1.0 - depth_mult: float = 1.0 - act: str = "silu" - - -class _HybridEncoderViTGConfig(_HybridEncoderConfig): - in_channels: list[int] = [1536, 1536, 1536] - feat_strides: list[int] = [7, 14, 28] - hidden_dim: int = 1536 - use_encoder_idx: list[int] = [2] - num_encoder_layers: int = 1 - nhead: int = 8 - dim_feedforward: int = 6144 - dropout: float = 0.0 - enc_act: str = "gelu" - expansion: float = 1.0 - depth_mult: float = 1.0 - act: str = "silu" - - -class _RTDETRTransformerv2Config(PydanticConfig): - feat_channels: list[int] - feat_strides: list[int] - hidden_dim: int - num_levels: int - num_layers: int - num_queries: int - num_denoising: int - label_noise_ratio: float - box_noise_scale: float - eval_idx: int - num_points: list[int] - query_select_method: str - - -class _RTDETRTransformerv2ViTSConfig(_RTDETRTransformerv2Config): - feat_channels: list[int] = [224, 224, 224] - feat_strides: list[int] = [7, 14, 28] - hidden_dim: int = 224 - num_levels: int = 3 - num_layers: int = 4 - num_queries: int = 300 - num_denoising: int = 100 - label_noise_ratio: float = 0.5 - box_noise_scale: float = 1.0 - eval_idx: int = -1 - num_points: list[int] = [3, 6, 3] - query_select_method: str = "default" - dim_feedforward: int = 1792 - - -class _RTDETRTransformerv2ViTBConfig(_RTDETRTransformerv2Config): - feat_channels: list[int] = [768, 768, 768] - feat_strides: list[int] = [7, 14, 28] - hidden_dim: int = 768 - num_levels: int = 3 - num_layers: int = 4 - num_queries: int = 300 - num_denoising: int = 100 - label_noise_ratio: float = 0.5 - box_noise_scale: float = 1.0 - eval_idx: int = -1 - num_points: list[int] = [3, 6, 3] - query_select_method: str = "default" - dim_feedforward: int = 6144 - - -class _RTDETRTransformerv2ViTLConfig(_RTDETRTransformerv2Config): - feat_channels: list[int] = [1024, 1024, 1024] - feat_strides: list[int] = [7, 14, 28] - hidden_dim: int = 1024 - num_levels: int = 3 - num_layers: int = 4 - num_queries: int = 300 - num_denoising: int = 100 - label_noise_ratio: float = 0.5 - box_noise_scale: float = 1.0 - eval_idx: int = -1 - num_points: list[int] = [3, 6, 3] - query_select_method: str = "default" - dim_feedforward: int = 8192 - - -class _RTDETRTransformerv2ViTGConfig(_RTDETRTransformerv2Config): - feat_channels: list[int] = [1536, 1536, 1536] - feat_strides: list[int] = [7, 14, 28] - hidden_dim: int = 1536 - num_levels: int = 3 - num_layers: int = 4 - num_queries: int = 300 - num_denoising: int = 100 - label_noise_ratio: float = 0.5 - box_noise_scale: float = 1.0 - eval_idx: int = -1 - num_points: list[int] = [3, 6, 3] - query_select_method: str = "default" - dim_feedforward: int = 12288 - - -class _DFINETransformerConfig(PydanticConfig): - feat_channels: list[int] - feat_strides: list[int] - hidden_dim: int - num_levels: int - num_layers: int - num_queries: int - num_denoising: int - label_noise_ratio: float - box_noise_scale: float - eval_idx: int - num_points: list[int] - query_select_method: str - cross_attn_method: str - dim_feedforward: int - reg_max: int - reg_scale: float - layer_scale: float - - -class _DFINETransformerViTSConfig(_DFINETransformerConfig): - feat_channels: list[int] = [224, 224, 224] - feat_strides: list[int] = [7, 14, 28] - hidden_dim: int = 224 - num_levels: int = 3 - num_layers: int = 4 - num_queries: int = 300 - num_denoising: int = 100 - label_noise_ratio: float = 0.5 - box_noise_scale: float = 1.0 - eval_idx: int = -1 - num_points: list[int] = [3, 6, 3] - query_select_method: str = "default" - cross_attn_method: str = "default" - dim_feedforward: int = 1792 - reg_max: int = 32 - reg_scale: float = 4.0 - layer_scale: float = 1.0 - - -class _DFINETransformerViTBConfig(_DFINETransformerConfig): - feat_channels: list[int] = [768, 768, 768] - feat_strides: list[int] = [7, 14, 28] - hidden_dim: int = 768 - num_levels: int = 3 - num_layers: int = 4 - num_queries: int = 300 - num_denoising: int = 100 - label_noise_ratio: float = 0.5 - box_noise_scale: float = 1.0 - eval_idx: int = -1 - num_points: list[int] = [3, 6, 3] - query_select_method: str = "default" - cross_attn_method: str = "default" - dim_feedforward: int = 6144 - reg_max: int = 32 - reg_scale: float = 4.0 - layer_scale: float = 1.0 - - -class _DFINETransformerViTLConfig(_DFINETransformerConfig): - feat_channels: list[int] = [1024, 1024, 1024] - feat_strides: list[int] = [7, 14, 28] - hidden_dim: int = 1024 - num_levels: int = 3 - num_layers: int = 4 - num_queries: int = 300 - num_denoising: int = 100 - label_noise_ratio: float = 0.5 - box_noise_scale: float = 1.0 - eval_idx: int = -1 - num_points: list[int] = [3, 6, 3] - query_select_method: str = "default" - cross_attn_method: str = "default" - dim_feedforward: int = 8192 - reg_max: int = 32 - reg_scale: float = 4.0 - layer_scale: float = 1.0 - - -class _DFINETransformerViTGConfig(_DFINETransformerConfig): - feat_channels: list[int] = [1536, 1536, 1536] - feat_strides: list[int] = [7, 14, 28] - hidden_dim: int = 1536 - num_levels: int = 3 - num_layers: int = 4 - num_queries: int = 300 - num_denoising: int = 100 - label_noise_ratio: float = 0.5 - box_noise_scale: float = 1.0 - eval_idx: int = -1 - num_points: list[int] = [3, 6, 3] - query_select_method: str = "default" - cross_attn_method: str = "default" - dim_feedforward: int = 12288 - reg_max: int = 32 - reg_scale: float = 4.0 - layer_scale: float = 1.0 - - -class _BackboneWrapperViTSConfig(PydanticConfig): - interaction_indexes: list[int] = [5, 8, 11] - finetune: bool = True - conv_inplane: int = 28 - hidden_dim: int = 224 - - -class _BackboneWrapperViTBConfig(PydanticConfig): - interaction_indexes: list[int] = [5, 8, 11] - finetune: bool = True - conv_inplane: int = 56 - hidden_dim: int = 768 - - -class _BackboneWrapperViTLConfig(PydanticConfig): - interaction_indexes: list[int] = [11, 17, 23] - finetune: bool = True - conv_inplane: int = 56 - hidden_dim: int = 1024 - - -class _BackboneWrapperViTGConfig(PydanticConfig): - interaction_indexes: list[int] = [19, 29, 39] - finetune: bool = True - conv_inplane: int = 64 - hidden_dim: int = 1536 - - -class _RTDETRPostProcessorConfig(PydanticConfig): - num_top_queries: int = 300 - - -class _DINOv2LTDETRObjectDetectionConfig(PydanticConfig): - decoder_name: _LTDETRDecoderName = "rtdetrv2" - hybrid_encoder: _HybridEncoderConfig - rtdetr_transformer: _RTDETRTransformerv2Config - dfine_transformer: _DFINETransformerConfig - rtdetr_postprocessor: _RTDETRPostProcessorConfig - - -class _DINOv2LTDETRObjectDetectionViTSConfig(_DINOv2LTDETRObjectDetectionConfig): - hybrid_encoder: _HybridEncoderViTSConfig = Field( - default_factory=_HybridEncoderViTSConfig - ) - rtdetr_transformer: _RTDETRTransformerv2ViTSConfig = Field( - default_factory=_RTDETRTransformerv2ViTSConfig - ) - dfine_transformer: _DFINETransformerViTSConfig = Field( - default_factory=_DFINETransformerViTSConfig - ) - rtdetr_postprocessor: _RTDETRPostProcessorConfig = Field( - default_factory=_RTDETRPostProcessorConfig - ) - backbone_wrapper: _BackboneWrapperViTSConfig = Field( - default_factory=_BackboneWrapperViTSConfig - ) - - -class _DINOv2LTDETRObjectDetectionViTBConfig(_DINOv2LTDETRObjectDetectionConfig): - hybrid_encoder: _HybridEncoderViTBConfig = Field( - default_factory=_HybridEncoderViTBConfig - ) - rtdetr_transformer: _RTDETRTransformerv2ViTBConfig = Field( - default_factory=_RTDETRTransformerv2ViTBConfig - ) - dfine_transformer: _DFINETransformerViTBConfig = Field( - default_factory=_DFINETransformerViTBConfig - ) - rtdetr_postprocessor: _RTDETRPostProcessorConfig = Field( - default_factory=_RTDETRPostProcessorConfig - ) - backbone_wrapper: _BackboneWrapperViTBConfig = Field( - default_factory=_BackboneWrapperViTBConfig - ) - - -class _DINOv2LTDETRObjectDetectionViTLConfig(_DINOv2LTDETRObjectDetectionConfig): - hybrid_encoder: _HybridEncoderViTLConfig = Field( - default_factory=_HybridEncoderViTLConfig - ) - rtdetr_transformer: _RTDETRTransformerv2ViTLConfig = Field( - default_factory=_RTDETRTransformerv2ViTLConfig - ) - dfine_transformer: _DFINETransformerViTLConfig = Field( - default_factory=_DFINETransformerViTLConfig - ) - rtdetr_postprocessor: _RTDETRPostProcessorConfig = Field( - default_factory=_RTDETRPostProcessorConfig - ) - backbone_wrapper: _BackboneWrapperViTLConfig = Field( - default_factory=_BackboneWrapperViTLConfig - ) - - -class _DINOv2LTDETRObjectDetectionViTGConfig(_DINOv2LTDETRObjectDetectionConfig): - hybrid_encoder: _HybridEncoderViTGConfig = Field( - default_factory=_HybridEncoderViTGConfig - ) - rtdetr_transformer: _RTDETRTransformerv2ViTGConfig = Field( - default_factory=_RTDETRTransformerv2ViTGConfig - ) - dfine_transformer: _DFINETransformerViTGConfig = Field( - default_factory=_DFINETransformerViTGConfig - ) - rtdetr_postprocessor: _RTDETRPostProcessorConfig = Field( - default_factory=_RTDETRPostProcessorConfig - ) - backbone_wrapper: _BackboneWrapperViTGConfig = Field( - default_factory=_BackboneWrapperViTGConfig - ) - - -class DINOv2LTDETRObjectDetection(TaskModel): - model_suffix = "ltdetr" - - def __init__( - self, - *, - model_name: str, - classes: dict[int, str], - image_size: tuple[int, int], - image_normalize: dict[str, tuple[float, ...]] | None = None, - backbone_freeze: bool = False, - backbone_weights: PathLike | None = None, - backbone_args: dict[str, Any] | None = None, - decoder_name: _LTDETRDecoderName = "rtdetrv2", - load_weights: bool = True, - ) -> None: - super().__init__( - init_args=locals(), ignore_args={"backbone_weights", "load_weights"} - ) - parsed_name = self.parse_model_name(model_name=model_name) - - self.model_name = parsed_name["model_name"] - self.image_size = image_size - self.classes = classes - self.backbone_freeze = backbone_freeze - - # Internally, the model processes classes as contiguous integers starting at 0. - # This list maps the internal class id to the class id in `classes`. - internal_class_to_class = list(self.classes.keys()) - - # Efficient lookup for converting internal class IDs to class IDs. - # Registered as buffer to be automatically moved to the correct device. - self.internal_class_to_class: Tensor - self.register_buffer( - "internal_class_to_class", - torch.tensor(internal_class_to_class, dtype=torch.long), - persistent=False, # No need to save it in the state dict. - ) - self.included_classes: dict[int, str] = { - internal_class_id: class_name - for internal_class_id, class_name in enumerate(self.classes.values()) - } - - self.image_normalize = image_normalize - - # Resolve the backbone's expected input channel count using the same - # precedence as DINOV2_VIT_PACKAGE.get_model: backbone_args["in_chans"] - # overrides image_normalize, which overrides the DINOv2 default of 3. - if backbone_args is not None and "in_chans" in backbone_args: - self._expected_input_channels: int = backbone_args["in_chans"] - elif self.image_normalize is not None: - self._expected_input_channels = len(self.image_normalize["mean"]) - else: - self._expected_input_channels = 3 - - # Instantiate the backbone. - dinov2 = DINOV2_VIT_PACKAGE.get_model( - model_name=parsed_name["backbone_name"], - model_args=backbone_args, - load_weights=load_weights, - ) - - # Optionally load the backbone weights. - if load_weights and backbone_weights is not None: - self.load_backbone_weights(dinov2, backbone_weights) - - # Get the configuration based on the model name. - config_mapping = { - "_vittest14": _DINOv2LTDETRObjectDetectionViTSConfig, - "vits14": _DINOv2LTDETRObjectDetectionViTSConfig, - "vitb14": _DINOv2LTDETRObjectDetectionViTBConfig, - "vitl14": _DINOv2LTDETRObjectDetectionViTLConfig, - "vitg14": _DINOv2LTDETRObjectDetectionViTGConfig, - } - config_name = parsed_name["backbone_name"].replace("-notpretrained", "") - config_name = config_name.replace("-noreg", "") - config_cls = config_mapping[config_name] - config = config_cls() - config.decoder_name = decoder_name - - # TODO(Guarin, 02/26): Improve how mask tokens are handled for fine-tuning. - dinov2.mask_token.requires_grad = False # type: ignore - - model_wrapper = DINOv2ViTModelWrapper(dinov2) - self.backbone: DINOv2STAs = DINOv2STAs( - model_wrapper=model_wrapper, - # Disable STA for DINOv2 as it doesn't work well with patch size 14. - use_sta=False, - **config.backbone_wrapper.model_dump(), - ) - - self.encoder: HybridEncoder = HybridEncoder( # type: ignore[no-untyped-call] - **config.hybrid_encoder.model_dump() - ) - - self.decoder = _build_decoder( - config=config, - decoder_name=config.decoder_name, - num_classes=len(self.classes), - image_size=self.image_size, - ) - - postprocessor_config = config.rtdetr_postprocessor.model_dump() - postprocessor_config.update({"num_classes": len(self.classes)}) - self.postprocessor: RTDETRPostProcessor = RTDETRPostProcessor( - **postprocessor_config - ) - - if self.backbone_freeze: - self.freeze_backbone() - - @classmethod - def list_model_names(cls) -> list[str]: - return [ - f"{name}-{cls.model_suffix}" - for name in DINOV2_VIT_PACKAGE.list_model_names() - ] - - @classmethod - def is_supported_model(cls, model: str) -> bool: - try: - cls.parse_model_name(model_name=model) - except ValueError: - return False - else: - return True - - @classmethod - def parse_model_name(cls, model_name: str) -> dict[str, str]: - def raise_invalid_name() -> None: - raise ValueError( - f"Model name '{model_name}' is not supported. Available " - f"models are: {cls.list_model_names()}." - ) - - if not model_name.endswith(f"-{cls.model_suffix}"): - raise_invalid_name() - - backbone_name = model_name[: -len(f"-{cls.model_suffix}")] - - try: - package_name, backbone_name = package_helpers.parse_model_name( - backbone_name - ) - except ValueError: - raise_invalid_name() - - if package_name != DINOV2_VIT_PACKAGE.name: - raise_invalid_name() - - try: - backbone_name = DINOV2_VIT_PACKAGE.parse_model_name( - model_name=backbone_name - ) - except ValueError: - raise_invalid_name() - - return { - "model_name": f"{DINOV2_VIT_PACKAGE.name}/{backbone_name}-{cls.model_suffix}", - "backbone_name": backbone_name, - } - - def freeze_backbone(self) -> None: - self.backbone.eval() - self.backbone.requires_grad_(False) - - def load_train_state_dict( - self, state_dict: dict[str, Any], strict: bool = True, assign: bool = False - ) -> Any: - """Load the state dict from a training checkpoint. - - Loads the EMA weights if available, otherwise falls back to the model weights. - """ - has_ema_weights = any(k.startswith("ema_model.model.") for k in state_dict) - has_model_weights = any(k.startswith("model.") for k in state_dict) - new_state_dict = {} - if has_ema_weights: - for name, param in state_dict.items(): - if name.startswith("ema_model.model."): - name = name[len("ema_model.model.") :] - new_state_dict[name] = param - elif has_model_weights: - for name, param in state_dict.items(): - if name.startswith("model."): - name = name[len("model.") :] - new_state_dict[name] = param - return self.load_state_dict(new_state_dict, strict=strict, assign=assign) - - def load_backbone_weights(self, backbone: Module, path: PathLike) -> None: - """ - Load backbone weights from a checkpoint file. - - Args: - backbone: backbone to load the statedict in. - path: path to a .pt file, e.g., exported_last.pt. - """ - path = Path(path).resolve() - if not path.exists(): - raise FileNotFoundError(f"Backbone weights file not found: '{path}'") - - # Load the checkpoint. - state_dict = torch.load(path, map_location="cpu", weights_only=False) - - # Load the state dict into the backbone. - missing, unexpected = backbone.load_state_dict(state_dict, strict=False) - - # Log missing and unexpected keys. - if missing or unexpected: - if missing: - logger.warning(f"Missing keys when loading backbone: {missing}") - if unexpected: - logger.warning(f"Unexpected keys when loading backbone: {unexpected}") - else: - logger.info(f"Backbone weights loaded from '{path}'") - - def deploy(self) -> Self: - self.eval() - self.postprocessor.deploy() # type: ignore[no-untyped-call] - for m in self.modules(): - if hasattr(m, "convert_to_deploy"): - m.convert_to_deploy() # type: ignore[operator] - return self - - def preprocess_image( - self, image: PathLike | PILImage | Tensor - ) -> tuple[Tensor, dict[str, Any]]: - first_param = next(self.parameters()) - device, dtype = first_param.device, first_param.dtype - - x = file_helpers.as_image_tensor(image).to(device) - image_h, image_w = x.shape[-2:] - - # Expand grayscale to the expected channel count so images can be stacked. - # TODO(Nauryzbay, 05/26): Revisit grayscale handling — the implicit - # 1-channel expansion is a convenience inherited from RGB-only models. - expected_c = self._expected_input_channels - if x.shape[-3] == 1 and expected_c > 1: - x = x.expand(expected_c, -1, -1) - elif x.shape[-3] != expected_c: - raise ValueError( - f"Image has {x.shape[-3]} channels but model expects {expected_c}." - ) - - x = transforms_functional.to_dtype(x, dtype=dtype, scale=True) - x = transforms_functional.resize(x, self.image_size) - return x, {"orig_h": image_h, "orig_w": image_w} - - def preprocess_batch(self, batch: Tensor) -> Tensor: - if self.image_normalize is not None: - batch = transforms_functional.normalize( - batch, - mean=list(self.image_normalize["mean"]), - std=list(self.image_normalize["std"]), - ) - return batch - - def forward_backend(self, x: Tensor) -> Any: - x = self.backbone(x) - x = self.encoder(x) - return self.decoder(x) - - def postprocess( # type: ignore[override] - self, - raw_outputs: Any | dict[str, Tensor], - metadata: Sequence[dict[str, Any]], - threshold: float, - ) -> list[dict[str, Tensor]]: - if not isinstance(raw_outputs, dict): - raise ValueError( - f"Expected raw_outputs to be a dict, got {type(raw_outputs).__name__}." - ) - device = next(self.parameters()).device - # Postprocessor expects (W, H) per image. - orig_target_size = torch.tensor( - [[m["orig_w"], m["orig_h"]] for m in metadata], - dtype=torch.int64, - device=device, - ) - postprocessor_out: tuple[Tensor, Tensor, Tensor] = self.postprocessor( - raw_outputs, orig_target_size - ) - out: list[dict[str, Tensor]] = [] - labels_batch, boxes_batch, scores_batch = postprocessor_out - - labels_batch = self.internal_class_to_class[labels_batch] - for i in range(len(metadata)): - keep = scores_batch[i] > threshold - out.append( - { - "labels": labels_batch[i][keep], - "bboxes": boxes_batch[i][keep], - "scores": scores_batch[i][keep], - } - ) - return out - - @torch.no_grad() - def predict_batch( - self, - images: Sequence[PathLike | PILImage | Tensor], - threshold: float = 0.6, - ) -> list[dict[str, Tensor]]: - """Run inference on a batch of images and return per-image detections. - - Args: - images: - Sequence of input images. Each can be a path, a PIL image, or a - tensor of shape (C, H, W). - threshold: - Score threshold to filter low-confidence predictions. Predictions - with scores <= threshold are discarded. - - Returns: - A list with one dict per input image. Each dict contains: - - "labels": Tensor of shape (N,) with predicted class indices. - - "bboxes": Tensor of shape (N, 4) with bounding boxes in - (x_min, y_min, x_max, y_max) in absolute pixel coordinates of the - original image. - - "scores": Tensor of shape (N,) with confidence scores. - """ - self._track_inference() - if self.training or not self.postprocessor.deploy_mode: - self.deploy() - tensors: list[Tensor] = [] - metadata: list[dict[str, Any]] = [] - for image in images: - x, meta = self.preprocess_image(image) - tensors.append(x) - metadata.append(meta) - batch = torch.stack(tensors, dim=0) - batch = self.preprocess_batch(batch) - raw = self.forward_backend(batch) - return self.postprocess(raw, metadata, threshold=threshold) - - @torch.no_grad() - def predict( - self, image: PathLike | PILImage | Tensor, threshold: float = 0.6 - ) -> dict[str, Tensor]: - """Run inference on a single image and return detected boxes, labels and scores. - - Args: - image: - Input image. Can be a path, a PIL image, or a tensor of shape (C, H, W). - threshold: - Score threshold to filter low-confidence predictions. Predictions with - scores <= threshold are discarded. - - Returns: - A dictionary with: - - "labels": Tensor of shape (N,) with predicted class indices. - - "bboxes": Tensor of shape (N, 4) with bounding boxes in - (x_min, y_min, x_max, y_max) in absolute pixel coordinates of the - original image. - - "scores": Tensor of shape (N,) with confidence scores for each prediction. - """ - self._track_inference() - if self.training or not self.postprocessor.deploy_mode: - self.deploy() - x, metadata = self.preprocess_image(image) - batch = self.preprocess_batch(x.unsqueeze(0)) - raw = self.forward_backend(batch) - return self.postprocess(raw, [metadata], threshold=threshold)[0] - - @torch.no_grad() - def predict_sahi( - self, - image: PathLike | PILImage | Tensor, - threshold: float = 0.6, - overlap: float = 0.2, - nms_iou_threshold: float = 0.3, - global_local_iou_threshold: float = 0.1, - ) -> dict[str, Tensor]: - """Run Slicing Aided Hyper Inference (SAHI) inference on the input image. - - The image is first converted to a tensor, then: - - - Tiled into overlapping crops of size `self.image_size`. - - A resized full-image version is added as a "global" tile. - - All tiles (global + local) are passed through the model in parallel. - - Predictions are filtered by score and merged using NMS and a global/local - consistency heuristic. NMS is only applied on tiles predictions. - The heuristic discards tiles predictions that heavily overlaps with global - predictions. - - Args: - image: - Input image. Can be a path, a PIL image, or a tensor of shape (C, H, W). - threshold: - Score threshold for filtering low-confidence predictions. - overlap: - Fractional overlap between tiles in [0, 1). 0.0 means no overlap. - nms_iou_threshold: - IoU threshold used for non-maximum suppression when merging predictions - from tiles and global image. A lower nms_iou_threshold value yields less - predictions. - global_local_iou_threshold: - Minimum IoU required to consider a tile prediction as matching a global - prediction when combining them. A lower global_local_iou_threshold - yields less predictions. - - Returns: - A dictionary with: - - "labels": Tensor of shape (N,) with predicted class indices. - - "bboxes": Tensor of shape (N, 4) with bounding boxes in - (x_min, y_min, x_max, y_max) in absolute pixel coordinates of the original image. - - "scores": Tensor of shape (N,) with confidence scores for each prediction. - """ - - if self.training or not self.postprocessor.deploy_mode: - self.deploy() - - device = next(self.parameters()).device - x = file_helpers.as_image_tensor(image).to(device) - - # Tile the image. - tiles, tiles_coordinates = tiling_utils.tile_image(x, overlap, self.image_size) - - # Prepare the full image tile - h, w = x.shape[-2:] - x = transforms_functional.resize(x, self.image_size) - x = x.unsqueeze(0) - tiles = torch.cat([x, tiles], dim=0) - - # Normalize the tiles and the image together. - tiles = transforms_functional.to_dtype(tiles, dtype=torch.float32, scale=True) - - # Normalize the image. - if self.image_normalize is not None: - tiles = transforms_functional.normalize( - tiles, - mean=self.image_normalize["mean"], - std=self.image_normalize["std"], - ) - - # Prepare the image/tiles sizes. - orig_target_sizes = torch.tensor([self.image_size], device=device).repeat( - len(tiles), 1 - ) - orig_target_sizes[0, 0] = h - orig_target_sizes[0, 1] = w - - # Feed the tiles in parallel to the model. - labels, boxes, scores = self(tiles, orig_target_size=orig_target_sizes) - - # Add coordinates of the tiles to the boxes. - tiles_coordinates = ( - tiles_coordinates.repeat(1, 2).unsqueeze(1).expand(-1, boxes.shape[1], -1) - ) - boxes[1:] += tiles_coordinates - - # Reorganize the predictions. - boxes_global = boxes[0].view(-1, 4) - boxes_tiles = boxes[1:].view(-1, 4) - labels_global = labels[0].flatten() - labels_tiles = labels[1:].flatten() - scores_global = scores[0].flatten() - scores_tiles = scores[1:].flatten() - - # Discard low-confidence predictions. - keep_global = scores_global > threshold - keep_tiles = scores_tiles > threshold - - # Combine global and tiles predictions. - labels, boxes, scores = tiling_utils.combine_predictions_tiles_and_global( - pred_global={ - "labels": labels_global[keep_global], - "bboxes": boxes_global[keep_global], - "scores": scores_global[keep_global], - }, - pred_tiles={ - "labels": labels_tiles[keep_tiles], - "bboxes": boxes_tiles[keep_tiles], - "scores": scores_tiles[keep_tiles], - }, - nms_iou_threshold=nms_iou_threshold, - global_local_iou_threshold=global_local_iou_threshold, - ) - - return { - "labels": labels, - "bboxes": boxes, - "scores": scores, - } - - def forward( - self, x: Tensor, orig_target_size: Tensor | None = None - ) -> tuple[Tensor, Tensor, Tensor]: - # Function used for ONNX export - # TODO (Simon, 05/26) This class does not seem to have an export_onnx function - if orig_target_size is None: - h, w = x.shape[-2:] - orig_target_size_ = torch.tensor([[w, h]]).to(x.device) - else: - # Flip from (H, W) to (W, H). - orig_target_size = orig_target_size[:, [1, 0]] - - # Move to device. - orig_target_size_ = orig_target_size.to(device=x.device, dtype=torch.int64) - - # Forward the image through the model. - x = self.backbone(x) - x = self.encoder(x) - x = self.decoder(x) - - result: list[dict[str, Tensor]] | tuple[Tensor, Tensor, Tensor] = ( - self.postprocessor(x, orig_target_size_) - ) - # Postprocessor must be in deploy mode at this point. It returns only tuples - # during deploy mode. - assert isinstance(result, tuple) - labels, boxes, scores = result - labels = self.internal_class_to_class[labels] - return (labels, boxes, scores) - - def _forward_train(self, x: Tensor, targets): # type: ignore[no-untyped-def] - x = self.backbone(x) - x = self.encoder(x) - x = self.decoder(feats=x, targets=targets) - return x - - -class DINOv2LTDETRDSPObjectDetection(DINOv2LTDETRObjectDetection): - model_suffix = "ltdetr-dsp" - - def __init__( - self, - *, - model_name: str, - classes: dict[int, str], - image_size: tuple[int, int], - image_normalize: dict[str, tuple[float, ...]] | None = None, - backbone_freeze: bool = False, - backbone_weights: PathLike | None = None, - backbone_args: dict[str, Any] | None = None, - decoder_name: _LTDETRDecoderName = "rtdetrv2", - ) -> None: - super(DINOv2LTDETRObjectDetection, self).__init__( - init_args=locals(), ignore_args={"backbone_weights"} - ) - parsed_name = self.parse_model_name(model_name=model_name) - - self.model_name = parsed_name["model_name"] - self.image_size = image_size - self.classes = classes - self.backbone_freeze = backbone_freeze - - # Internally, the model processes classes as contiguous integers starting at 0. - # This list maps the internal class id to the class id in `classes`. - internal_class_to_class = list(self.classes.keys()) - - # Efficient lookup for converting internal class IDs to class IDs. - # Registered as buffer to be automatically moved to the correct device. - self.internal_class_to_class: Tensor - self.register_buffer( - "internal_class_to_class", - torch.tensor(internal_class_to_class, dtype=torch.long), - persistent=False, # No need to save it in the state dict. - ) - - self.image_normalize = image_normalize - - if backbone_args is not None and "in_chans" in backbone_args: - self._expected_input_channels: int = backbone_args["in_chans"] - elif self.image_normalize is not None: - self._expected_input_channels = len(self.image_normalize["mean"]) - else: - self._expected_input_channels = 3 - - dinov2 = DINOV2_VIT_PACKAGE.get_model( - model_name=parsed_name["backbone_name"], - model_args=backbone_args, - ) - - # Get the configuration based on the model name. - config_mapping = { - "vits14": _DINOv2LTDETRObjectDetectionViTSConfig, - "vitb14": _DINOv2LTDETRObjectDetectionViTBConfig, - "vitl14": _DINOv2LTDETRObjectDetectionViTLConfig, - "vitg14": _DINOv2LTDETRObjectDetectionViTGConfig, - } - config_name = parsed_name["backbone_name"] - config_cls = config_mapping[config_name] - config = config_cls() - config.decoder_name = decoder_name - - model_wrapper = DINOv2ViTModelWrapper(dinov2) - self.backbone: DINOv2STAs = DINOv2STAs( - model_wrapper=model_wrapper, - # Disable STA for DINOv2 as it doesn't work well with patch size 14. - use_sta=False, - **config.backbone_wrapper.model_dump(), - ) - - self.encoder: HybridEncoder = HybridEncoder( # type: ignore[no-untyped-call] - **config.hybrid_encoder.model_dump() - ) - - self.decoder = _build_decoder( - config=config, - decoder_name=config.decoder_name, - num_classes=len(self.classes), - image_size=self.image_size, - cross_attn_method="discrete", - ) - - postprocessor_config = config.rtdetr_postprocessor.model_dump() - self.postprocessor: RTDETRPostProcessor = RTDETRPostProcessor( - **postprocessor_config - ) - - -def _build_decoder( - *, - config: _DINOv2LTDETRObjectDetectionConfig, - decoder_name: _LTDETRDecoderName, - num_classes: int, - image_size: tuple[int, int], - cross_attn_method: str | None = None, -) -> RTDETRTransformerv2 | DFINETransformer: - if decoder_name == "rtdetrv2": - decoder_config = config.rtdetr_transformer.model_dump() - if cross_attn_method is not None: - decoder_config["cross_attn_method"] = cross_attn_method - decoder_config.update({"num_classes": num_classes}) - return RTDETRTransformerv2( # type: ignore[no-untyped-call] - **decoder_config, - eval_spatial_size=image_size, - ) - elif decoder_name == "dfine": - decoder_config = config.dfine_transformer.model_dump() - if cross_attn_method is not None: - decoder_config["cross_attn_method"] = cross_attn_method - decoder_config.update({"num_classes": num_classes}) - return DFINETransformer( # type: ignore[no-untyped-call] - **decoder_config, - eval_spatial_size=image_size, - ) - else: - raise ValueError(f"Unsupported LTDETR decoder: {decoder_name}") diff --git a/src/lightly_train/_task_models/dinov2_ltdetr_object_detection/train_model.py b/src/lightly_train/_task_models/dinov2_ltdetr_object_detection/train_model.py deleted file mode 100644 index cf58b7fce..000000000 --- a/src/lightly_train/_task_models/dinov2_ltdetr_object_detection/train_model.py +++ /dev/null @@ -1,648 +0,0 @@ -# -# Copyright (c) Lightly AG and affiliates. -# All rights reserved. -# -# This source code is licensed under the license found in the -# LICENSE file in the root directory of this source tree. -# -from __future__ import annotations - -import copy -import logging -import math -from typing import Any, ClassVar, Literal - -import torch -from lightning_fabric import Fabric -from pydantic import AliasChoices, Field, computed_field -from torch import Tensor -from torch.nn.modules.module import _IncompatibleKeys -from torch.optim import AdamW, Optimizer # type: ignore[attr-defined] -from torch.optim.lr_scheduler import ( # type: ignore[attr-defined] - LinearLR, - LRScheduler, -) - -from lightly_train._configs.validate import no_auto -from lightly_train._data.task_data_args import TaskDataArgs -from lightly_train._data.yolo_object_detection_dataset import ( - YOLOObjectDetectionDataArgs, -) -from lightly_train._distributed import reduce_dict -from lightly_train._metrics.detection.task_metric import ( - ObjectDetectionTaskMetric, - ObjectDetectionTaskMetricArgs, -) -from lightly_train._optim import optimizer_helpers -from lightly_train._task_models.dinov2_ltdetr_object_detection.dinov2_vit_wrapper import ( - DINOv2STAs, -) -from lightly_train._task_models.dinov2_ltdetr_object_detection.task_model import ( - DINOv2LTDETRObjectDetection, -) -from lightly_train._task_models.dinov2_ltdetr_object_detection.transforms import ( - DINOv2LTDETRObjectDetectionTrainTransform, - DINOv2LTDETRObjectDetectionTrainTransformArgs, - DINOv2LTDETRObjectDetectionValTransform, - DINOv2LTDETRObjectDetectionValTransformArgs, -) -from lightly_train._task_models.object_detection_components.dfine_criterion import ( - DFINECriterion, -) -from lightly_train._task_models.object_detection_components.dfine_decoder import ( - DFINETransformer, -) -from lightly_train._task_models.object_detection_components.ema import ModelEMA -from lightly_train._task_models.object_detection_components.flat_cosine import ( - FlatCosineLRScheduler, -) -from lightly_train._task_models.object_detection_components.ltdetr_schedule import ( - resolve_ltdetr_step_schedule, -) -from lightly_train._task_models.object_detection_components.matcher import ( - HungarianMatcher, -) -from lightly_train._task_models.object_detection_components.rtdetrv2_criterion import ( - RTDETRCriterionv2, -) -from lightly_train._task_models.object_detection_components.utils import ( - _denormalize_xyxy_boxes, - _yolo_to_xyxy, -) -from lightly_train._task_models.task_model import TaskModel -from lightly_train._task_models.train_model import ( - TaskStepResult, - TrainModel, - TrainModelArgs, -) -from lightly_train._torch_compile import TorchCompileArgs -from lightly_train._visualize import object_detection -from lightly_train.types import ObjectDetectionBatch, PathLike - -_RTDETRV2_LOSS_WEIGHT_DICT: dict[str, float] = { - "loss_vfl": 1.0, - "loss_bbox": 5.0, - "loss_giou": 2.0, -} -_RTDETRV2_LOSSES: list[str] = ["vfl", "boxes"] -_RTDETRV2_LOSS_NAMES: list[str] = ["loss", *_RTDETRV2_LOSS_WEIGHT_DICT] - -_DFINE_EXTRA_LOSS_WEIGHT_DICT: dict[str, float] = {"loss_fgl": 0.15, "loss_ddf": 1.5} -_DFINE_EXTRA_LOSSES: list[str] = ["local"] -_DFINE_LOSS_NAMES: list[str] = [*_RTDETRV2_LOSS_NAMES, *_DFINE_EXTRA_LOSS_WEIGHT_DICT] -logger = logging.getLogger(__name__) - - -class DINOv2LTDETRObjectDetectionTrainArgs(TrainModelArgs): - default_batch_size: ClassVar[int] = 16 - default_steps: ClassVar[int] = ( - 100_000 // 16 * 72 - ) # TODO (Lionel, 10/25): Adjust default steps. - - backbone_weights: PathLike | None = None - backbone_url: str = "" - backbone_args: dict[str, Any] = {} - backbone_freeze: bool = False - decoder_name: Literal["rtdetrv2", "dfine"] = "rtdetrv2" - - use_ema_model: bool = True - ema_momentum: float = 0.9999 - ema_warmup_steps: int = 2000 - - # TODO(Thomas, 10/25): use separate dataclass for optimizer, matcher, etc. - # Matcher configuration - matcher_weight_dict: dict[str, float] = Field( - default_factory=lambda: {"cost_class": 2.0, "cost_bbox": 5.0, "cost_giou": 2.0} - ) - matcher_use_focal_loss: bool = True - matcher_alpha: float = 0.25 - matcher_gamma: float = 2.0 - - # Criterion configuration - loss_weight_dict: dict[str, float] = Field( - default_factory=lambda: dict(_RTDETRV2_LOSS_WEIGHT_DICT) - ) - losses: list[str] = Field(default_factory=lambda: list(_RTDETRV2_LOSSES)) - loss_alpha: float = 0.75 - loss_gamma: float = 2.0 - - # Miscellaneous - gradient_clip_val: float = 0.1 - - # Optimizer configuration - lr: float = Field( - default=1e-4, - validation_alias=AliasChoices("lr", "optimizer_lr"), - ) - weight_decay: float = Field( - default=1e-4, - validation_alias=AliasChoices("weight_decay", "optimizer_weight_decay"), - ) - optimizer_betas: tuple[float, float] = (0.9, 0.999) - - # Per-parameter-group overrides - backbone_lr_factor: float = 1e-2 - - # Scheduler configuration - scheduler_name: Literal["linear", "flat-cosine"] = "linear" - scheduler_start_factor: float = 0.01 - lr_warmup_steps: int = Field( - default=2000, - validation_alias=AliasChoices("lr_warmup_steps", "scheduler_warmup_steps"), - ) - scheduler_flat_steps: int | Literal["auto"] = "auto" - scheduler_no_aug_steps: int | Literal["auto"] = "auto" - - def resolve_auto( - self, - total_steps: int, - gradient_accumulation_steps: int, - train_num_batches: int, - model_name: str, - model_init_args: dict[str, Any], - data_args: TaskDataArgs, - ) -> None: - if self.scheduler_flat_steps == "auto" or self.scheduler_no_aug_steps == "auto": - scheduler_step_schedule = resolve_ltdetr_step_schedule( - total_steps=total_steps, - train_num_batches=train_num_batches, - gradient_accumulation_steps=gradient_accumulation_steps, - ) - if self.scheduler_flat_steps == "auto": - self.scheduler_flat_steps = scheduler_step_schedule.step_flat - if self.scheduler_no_aug_steps == "auto": - self.scheduler_no_aug_steps = ( - total_steps - scheduler_step_schedule.step_stop - ) - - @computed_field # type: ignore[prop-decorator] - @property - def effective_loss_weight_dict(self) -> dict[str, float]: - if self.decoder_name == "dfine": - return {**_DFINE_EXTRA_LOSS_WEIGHT_DICT, **self.loss_weight_dict} - return dict(self.loss_weight_dict) - - @computed_field # type: ignore[prop-decorator] - @property - def effective_losses(self) -> list[str]: - if self.decoder_name == "dfine": - return [ - *self.losses, - *(name for name in _DFINE_EXTRA_LOSSES if name not in self.losses), - ] - return list(self.losses) - - -class DINOv2LTDETRObjectDetectionTrain(TrainModel): - task = "object_detection" - train_model_args_cls = DINOv2LTDETRObjectDetectionTrainArgs - task_metric_args_cls = ObjectDetectionTaskMetricArgs - task_model_cls = DINOv2LTDETRObjectDetection - train_transform_cls = DINOv2LTDETRObjectDetectionTrainTransform - val_transform_cls = DINOv2LTDETRObjectDetectionValTransform - torch_compile_args_cls = TorchCompileArgs - - def __init__( - self, - *, - model_name: str, - model_args: DINOv2LTDETRObjectDetectionTrainArgs, - data_args: YOLOObjectDetectionDataArgs, - train_transform_args: DINOv2LTDETRObjectDetectionTrainTransformArgs, - val_transform_args: DINOv2LTDETRObjectDetectionValTransformArgs, - load_weights: bool, - metric_args: ObjectDetectionTaskMetricArgs, - gradient_accumulation_steps: int, - ) -> None: - super().__init__() - - self.model_args = model_args - self.data_args = data_args - - # Get the normalization. - normalize = no_auto(val_transform_args.normalize) - normalize_dict: dict[str, Any] | None - self._normalize = normalize - - if normalize is None: - normalize_dict = None - else: - normalize_dict = normalize.model_dump() - - self.model = DINOv2LTDETRObjectDetection( - model_name=model_name, - image_size=no_auto(val_transform_args.image_size), - classes=data_args.included_classes, - image_normalize=normalize_dict, - backbone_freeze=model_args.backbone_freeze, - backbone_weights=model_args.backbone_weights, - backbone_args=model_args.backbone_args, # TODO (Lionel, 10/25): Potentially remove in accordance with EoMT. - decoder_name=model_args.decoder_name, - load_weights=load_weights, - ) - - self.ema_model_state_dict_key_prefix = "ema_model." - self.ema_model: ModelEMA | None = None - if model_args.use_ema_model: - self.ema_model = ModelEMA( - model=self.model, - decay=model_args.ema_momentum, - warmups=model_args.ema_warmup_steps, - ) - - matcher = HungarianMatcher( # type: ignore[no-untyped-call] - weight_dict=model_args.matcher_weight_dict, - use_focal_loss=model_args.matcher_use_focal_loss, - alpha=model_args.matcher_alpha, - gamma=model_args.matcher_gamma, - ) - - criterion: DFINECriterion | RTDETRCriterionv2 - if model_args.decoder_name == "dfine": - self.train_loss_names = _DFINE_LOSS_NAMES - self.val_loss_names = _RTDETRV2_LOSS_NAMES - if not isinstance(self.model.decoder, DFINETransformer): - raise TypeError("decoder='dfine' requires a DFINETransformer decoder.") - criterion = DFINECriterion( # type: ignore[no-untyped-call] - matcher=matcher, - weight_dict=model_args.effective_loss_weight_dict, - losses=model_args.effective_losses, - alpha=model_args.loss_alpha, - gamma=model_args.loss_gamma, - num_classes=len(data_args.included_classes), - reg_max=self.model.decoder.reg_max, - ) - else: - self.train_loss_names = _RTDETRV2_LOSS_NAMES - self.val_loss_names = _RTDETRV2_LOSS_NAMES - criterion = RTDETRCriterionv2( # type: ignore[no-untyped-call] - matcher=matcher, - weight_dict=model_args.effective_loss_weight_dict, - losses=model_args.effective_losses, - alpha=model_args.loss_alpha, - gamma=model_args.loss_gamma, - num_classes=len(data_args.included_classes), - ) - self.criterion = criterion - - class_names = list(data_args.included_classes.values()) - self.metric_args = metric_args - self.train_metrics = ObjectDetectionTaskMetric( - task_metric_args=metric_args, - split="train", - class_names=class_names, - box_format="xyxy", - loss_names=self.train_loss_names, - train_loss_running_mean_window=gradient_accumulation_steps, - ) - self.val_metrics = ObjectDetectionTaskMetric( - task_metric_args=metric_args, - split="val", - class_names=class_names, - box_format="xyxy", - loss_names=self.val_loss_names, - ) - - # TODO(Nauryz, 04/2026): These visualization thresholds are currently hardcoded, but we may want to make them configurable in the future (with logger_args). - self.viz_score_threshold = 0.1 - self.viz_max_images = 4 - - def load_train_state_dict( - self, state_dict: dict[str, Any], strict: bool = True, assign: bool = False - ) -> Any: - """Loads the model state dict. - - Overloads the default implementation to use the task model's loading logic. - This allows loading weights from an EMA model into the training model. - """ - missing_keys, unexpected_keys = self.model.load_train_state_dict( - state_dict, - strict=strict, - assign=assign, - ) - if self.ema_model is not None: - missing_keys_ema, unexpected_keys_ema = ( - self.ema_model.model.load_train_state_dict( # type: ignore - # Copy to avoid assigning the same weights to both models - copy.deepcopy(state_dict), - strict=strict, - assign=assign, - ) - ) - missing_keys.extend(missing_keys_ema) - unexpected_keys.extend(unexpected_keys_ema) - return _IncompatibleKeys(missing_keys, unexpected_keys) - - def get_export_state_dict(self) -> dict[str, Any]: - """Returns the state dict for exporting.""" - state_dict = super().get_export_state_dict() - if self.ema_model is not None: - # Only keep EMA weights for export - state_dict = { - k: v - for k, v in state_dict.items() - if k.startswith(self.ema_model_state_dict_key_prefix) - } - return state_dict - - def set_train_mode(self) -> None: - super().set_train_mode() - self.criterion.train() # TODO (Lionel, 10/25): Check if this is necessary. - if self.model_args.backbone_freeze: - self.model.freeze_backbone() - - def training_step( - self, fabric: Fabric, batch: ObjectDetectionBatch, step: int - ) -> TaskStepResult: - samples, boxes, classes = batch["image"], batch["bboxes"], batch["classes"] - targets: list[dict[str, Tensor]] = [ - {"boxes": boxes, "labels": classes} - for boxes, classes in zip(boxes, classes) - ] - outputs = self.model._forward_train( - x=samples, - targets=targets, - ) - # Additional kwargs are anyway ignore in RTDETRCriterionv2. - # The loss expects gt boxes in cxcywh format normalized in [0,1]. - loss_dict = self.criterion( - outputs=outputs, - targets=targets, - epoch=None, - step=None, - global_step=None, - world_size=fabric.world_size, - ) - total_loss = sum(loss_dict.values()) - - # Average loss dict across devices. - loss_dict = reduce_dict(loss_dict) - - # Metrics - self.train_metrics.update_with_losses( - loss_dict=_get_loss_log_dict( - total_loss=total_loss, - loss_dict=loss_dict, - loss_names=self.train_loss_names, - ), - weight=samples.shape[0], - ) - if self.metric_args.train: - orig_target_sizes = batch["original_size"] - # Convert to xyxy format and de-normalize the boxes. - boxes = _yolo_to_xyxy(boxes) - boxes_denormalized = _denormalize_xyxy_boxes(boxes, orig_target_sizes) - for target, sample_denormalized_boxes in zip(targets, boxes_denormalized): - target["boxes"] = sample_denormalized_boxes - - orig_target_sizes_tensor = torch.tensor( - orig_target_sizes, device=samples.device - ) - results: list[dict[str, Tensor]] = self.model.postprocessor( - outputs, orig_target_sizes=orig_target_sizes_tensor - ) - self.train_metrics.update_with_predictions(results, targets) - - return TaskStepResult( - loss=total_loss, - log_dict={}, - metrics=self.train_metrics, - visualization=object_detection.ObjectDetectionTaskStepVisualization( - batch=batch, - class_names=self.model.included_classes, - image_normalize=self.model.image_normalize, - max_images=self.viz_max_images, - score_threshold=self.viz_score_threshold, - ), - ) - - def on_train_batch_end(self) -> None: - if self.ema_model is not None: - self.ema_model.update(self.model) - - def validation_step( - self, - fabric: Fabric, - batch: ObjectDetectionBatch, - step: int, - ) -> TaskStepResult: - samples, boxes, classes, orig_target_sizes = ( - batch["image"], - batch["bboxes"], - batch["classes"], - batch["original_size"], - ) - targets = [ - {"boxes": boxes, "labels": classes} - for boxes, classes in zip(boxes, classes) - ] - - if self.ema_model is not None: - model_to_use = self.ema_model.model - else: - model_to_use = self.model - - with torch.no_grad(): - outputs = model_to_use._forward_train( # type: ignore - x=samples, - targets=targets, - ) - # TODO (Lionel, 10/25): Pass epoch, step, global_step. - # The loss expects gt boxes in cxcywh format normalized in [0,1]. - loss_dict = self.criterion( - outputs=outputs, - targets=targets, - epoch=None, - step=None, - global_step=None, - world_size=fabric.world_size, - ) - - total_loss = sum(loss_dict.values()) - - # Average loss dict across devices. - loss_dict = reduce_dict(loss_dict) - - # Convert to xyxy format and de-normalize the boxes. - boxes = _yolo_to_xyxy(boxes) - boxes_denormalized = _denormalize_xyxy_boxes(boxes, orig_target_sizes) - for target, sample_denormalized_boxes in zip(targets, boxes_denormalized): - target["boxes"] = sample_denormalized_boxes - - orig_target_sizes_tensor = torch.tensor( - orig_target_sizes, device=samples.device - ) - results: list[dict[str, Tensor]] = self.model.postprocessor( - outputs, orig_target_sizes=orig_target_sizes_tensor - ) - - # Metrics - self.val_metrics.update_with_losses( - loss_dict=_get_loss_log_dict( - total_loss=total_loss, - loss_dict=loss_dict, - loss_names=self.val_loss_names, - ), - weight=samples.shape[0], - ) - self.val_metrics.update_with_predictions(results, targets) - - return TaskStepResult( - loss=total_loss, - log_dict={}, - metrics=self.val_metrics, - visualization=object_detection.ObjectDetectionTaskStepVisualization( - batch=batch, - results=results, - class_names=self.model.included_classes, - image_normalize=self.model.image_normalize, - score_threshold=self.viz_score_threshold, - max_images=self.viz_max_images, - ), - ) - - def get_optimizer( - self, total_steps: int, global_batch_size: int - ) -> tuple[Optimizer, LRScheduler]: - _, params_no_wd_list = optimizer_helpers.get_weight_decay_parameters( - modules=[self.model] - ) - params_no_wd = set(params_no_wd_list) - - param_groups = [] - lr = self.model_args.lr * math.sqrt( - global_batch_size / self.model_args.default_batch_size - ) - backbone_lr = lr * self.model_args.backbone_lr_factor - - backbone = self.model.backbone - if isinstance(backbone, DINOv2STAs): - # Only the pretrained ViT gets the low backbone LR. - backbone_params = list(backbone.backbone_model.parameters()) - # The connector modules (sta, convs, norms) are randomly initialized and - # are merged into the detector group to train at the full LR. - vit_params_ids = {id(p) for p in backbone_params} - connector_params = [ - p for p in backbone.parameters() if id(p) not in vit_params_ids - ] - else: - backbone_params = list(backbone.parameters()) - connector_params = [] - - backbone_params_wd = [p for p in backbone_params if p not in params_no_wd] - backbone_params_no_wd = [p for p in backbone_params if p in params_no_wd] - if backbone_params_wd: - param_groups.append( - { - "name": "backbone", - "params": backbone_params_wd, - "lr": backbone_lr, - } - ) - if backbone_params_no_wd: - param_groups.append( - { - "name": "backbone_no_wd", - "params": backbone_params_no_wd, - "lr": backbone_lr, - "weight_decay": 0.0, - } - ) - - detector_params = ( - connector_params - + list(self.model.encoder.parameters()) - + list(self.model.decoder.parameters()) - ) - detector_params_wd = [p for p in detector_params if p not in params_no_wd] - detector_params_no_wd = [p for p in detector_params if p in params_no_wd] - if detector_params_wd: - param_groups.append( - { - "name": "detector", - "params": detector_params_wd, - } - ) - if detector_params_no_wd: - param_groups.append( - { - "name": "detector_no_wd", - "params": detector_params_no_wd, - "weight_decay": 0.0, - } - ) - - optim = AdamW( - param_groups, - lr=lr, - betas=self.model_args.optimizer_betas, - weight_decay=self.model_args.weight_decay, - ) - scheduler: LRScheduler - if self.model_args.scheduler_name == "linear": - if self.model_args.lr_warmup_steps > total_steps: - logger.warning( - f"{self.model_args.scheduler_name} scheduler has " - f"lr_warmup_steps={self.model_args.lr_warmup_steps} " - f"and total_steps={total_steps}; the schedule will not complete " - "as intended." - ) - scheduler = LinearLR( - optimizer=optim, - total_iters=self.model_args.lr_warmup_steps, - start_factor=self.model_args.scheduler_start_factor, - ) - elif self.model_args.scheduler_name == "flat-cosine": - scheduler = FlatCosineLRScheduler( - optimizer=optim, - total_steps=total_steps, - warmup_steps=self.model_args.lr_warmup_steps, - flat_steps=no_auto(self.model_args.scheduler_flat_steps), - no_aug_steps=no_auto(self.model_args.scheduler_no_aug_steps), - ) - else: - raise ValueError( - f"Unknown scheduler: {self.model_args.scheduler_name!r}. " - "Expected 'linear' or 'flat-cosine'." - ) - return optim, scheduler - - def get_task_model(self) -> TaskModel: - return self.model - - def clip_gradients(self, fabric: Fabric, optimizer: Optimizer) -> None: - if self.model_args.gradient_clip_val > 0: - fabric.clip_gradients( - module=self, - optimizer=optimizer, - max_norm=self.model_args.gradient_clip_val, - error_if_nonfinite=False, - ) - - -def _get_loss_log_dict( - *, - total_loss: Tensor, - loss_dict: dict[str, Tensor], - loss_names: list[str], -) -> dict[str, Tensor]: - zero = total_loss.new_zeros(()) - log_dict = {"loss": total_loss.detach()} - for loss_name in loss_names: - if loss_name == "loss": - continue - if loss_name == "loss_ddf": - loss_values = [ - v.detach() - for k, v in loss_dict.items() - if k == "loss_ddf" or k.startswith("loss_ddf_") - ] - if not loss_values: - raise KeyError( - "No loss entries found for 'loss_ddf'. Available losses: " - f"{sorted(loss_dict.keys())}" - ) - log_dict[loss_name] = sum(loss_values, start=zero) - else: - log_dict[loss_name] = loss_dict[loss_name].detach() - return log_dict diff --git a/src/lightly_train/_task_models/dinov2_ltdetr_object_detection/transforms.py b/src/lightly_train/_task_models/dinov2_ltdetr_object_detection/transforms.py deleted file mode 100644 index 67a08534d..000000000 --- a/src/lightly_train/_task_models/dinov2_ltdetr_object_detection/transforms.py +++ /dev/null @@ -1,376 +0,0 @@ -# -# Copyright (c) Lightly AG and affiliates. -# All rights reserved. -# -# This source code is licensed under the license found in the -# LICENSE file in the root directory of this source tree. -# -from __future__ import annotations - -from typing import Any, Literal, Sequence - -from albumentations import BboxParams -from lightning_utilities.core.imports import RequirementCache -from pydantic import Field - -from lightly_train._transforms.object_detection_transform import ( - ObjectDetectionTransform, - ObjectDetectionTransformArgs, - resolve_ltdetr_step_schedule_for_augmentation, -) -from lightly_train._transforms.transform import ( - CopyBlendArgs, - MixUpArgs, - MosaicArgs, - NormalizeArgs, - RandomFlipArgs, - RandomIoUCropArgs, - RandomPhotometricDistortArgs, - RandomRotate90Args, - RandomRotationArgs, - RandomZoomOutArgs, - ResizeArgs, - ScaleJitterArgs, -) -from lightly_train.types import ImageSizeTuple - -ALBUMENTATIONS_VERSION_GREATER_EQUAL_1_4_5 = RequirementCache("albumentations>=1.4.5") -ALBUMENTATIONS_VERSION_GREATER_EQUAL_2_0_1 = RequirementCache("albumentations>=2.0.1") - - -class DINOv2LTDETRObjectDetectionRandomPhotometricDistortArgs( - RandomPhotometricDistortArgs -): - prob: float = 0.5 - - brightness: tuple[float, float] = (0.875, 1.125) - contrast: tuple[float, float] = (0.5, 1.5) - saturation: tuple[float, float] = (0.5, 1.5) - hue: tuple[float, float] = (-0.05, 0.05) - - # "auto" resolves to epoch 4, or to floor(total_epochs / 3) for runs - # with <= 12 epochs. - step_start: int | Literal["auto"] = "auto" - # "auto" resolves to epoch total_epochs - no_aug_epoch. For shorter runs, - # no_aug_epoch is scaled following a certain rule. See :func:`resolve_ltdetr_step_schedule` for the full algorithm. - # None means photometric distort is always on. - step_stop: int | Literal["auto"] | None = "auto" - - -class DINOv2LTDETRObjectDetectionRandomZoomOutArgs(RandomZoomOutArgs): - prob: float = 0.5 - - fill: float = 0.0 - side_range: tuple[float, float] = (1.0, 4.0) - - # "auto" resolves to epoch 4, or to floor(total_epochs / 3) for runs - # with <= 12 epochs. - step_start: int | Literal["auto"] = "auto" - # "auto" resolves to epoch total_epochs - no_aug_epoch. For shorter runs, - # no_aug_epoch is scaled following a certain rule. See :func:`resolve_ltdetr_step_schedule` for the full algorithm. - # None means random zoom out is always on. - step_stop: int | Literal["auto"] | None = "auto" - - -class DINOv2LTDETRObjectDetectionRandomIoUCropArgs(RandomIoUCropArgs): - prob: float = 0.8 - - min_scale: float = 0.3 - max_scale: float = 1.0 - min_aspect_ratio: float = 0.5 - max_aspect_ratio: float = 2.0 - sampler_options: Sequence[float] | None = None - crop_trials: int = 40 - iou_trials: int = 1000 - - # "auto" resolves to epoch 4, or to floor(total_epochs / 3) for runs - # with <= 12 epochs. - step_start: int | Literal["auto"] = "auto" - # "auto" resolves to epoch total_epochs - no_aug_epoch. For shorter runs, - # no_aug_epoch is scaled following a certain rule. See :func:`resolve_ltdetr_step_schedule` for the full algorithm. - # None means random IoU crop is always on. - step_stop: int | Literal["auto"] | None = "auto" - - -class DINOv2LTDETRObjectDetectionRandomFlipArgs(RandomFlipArgs): - horizontal_prob: float = 0.5 - vertical_prob: float = 0.0 - - -class DINOv2LTDETRObjectDetectionScaleJitterArgs(ScaleJitterArgs): - # Sizes must be multiples of patch size * 2 - sizes: Sequence[tuple[int, int]] | None = [ - (476, 476), - (504, 504), - (532, 532), - (560, 560), - (588, 588), - (616, 616), - (644, 644), - (644, 644), - (644, 644), - (644, 644), - (644, 644), - (644, 644), - (644, 644), - (644, 644), - (644, 644), - (644, 644), - (644, 644), - (644, 644), - (644, 644), - (644, 644), - (644, 644), - (644, 644), - (644, 644), - (644, 644), - (644, 644), - (644, 644), - (672, 672), - (700, 700), - (728, 728), - (756, 756), - (784, 784), - (812, 812), - ] - min_scale: float | None = None - max_scale: float | None = None - num_scales: int | None = None - prob: float = 1.0 - divisible_by: int | None = None - - # "auto" resolves to epoch total_epochs - no_aug_epoch. For shorter runs, - # no_aug_epoch is scaled following a certain rule. See :func:`resolve_ltdetr_step_schedule` for the full algorithm. - # None means scale jitter is always on. - step_stop: int | Literal["auto"] | None = "auto" - - -class DINOv2LTDETRObjectDetectionMixUpArgs(MixUpArgs): - prob: float = 0.5 - - # "auto" resolves to epoch 4, or to floor(total_epochs / 3) for runs - # with <= 12 epochs. - step_start: int | Literal["auto"] = "auto" - # "auto" uses a compressed short-run schedule for <= 12 epochs and - # transitions to the midpoint rule on longer runs. - # None means mixup is always on. - step_stop: int | Literal["auto"] | None = "auto" - - -class DINOv2LTDETRObjectDetectionCopyBlendArgs(CopyBlendArgs): - prob: float = 0.5 - - area_threshold: int = 100 - num_objects: int = 3 - expand_ratios: tuple[float, float] = (0.1, 0.25) - - # "auto" resolves to epoch 4, or to floor(total_epochs / 3) for runs - # with <= 12 epochs. - step_start: int | Literal["auto"] = "auto" - # "auto" resolves to epoch total_epochs - no_aug_epoch. For shorter runs, - # no_aug_epoch is scaled following a certain rule. See :func:`resolve_ltdetr_step_schedule` for the full algorithm. - # None means copy blend is always on. - step_stop: int | Literal["auto"] | None = "auto" - - -class DINOv2LTDETRObjectDetectionMosaicArgs(MosaicArgs): - prob: float = 0.5 - - output_size: int = 320 - max_size: int | None = None - rotation_range: float = 10.0 - translation_range: tuple[float, float] = (0.1, 0.1) - scaling_range: tuple[float, float] = (0.5, 1.5) - fill_value: int | float = 0 - max_cached_images: int = 50 - random_pop: bool = True - - # "auto" resolves to epoch 4, or to floor(total_epochs / 3) for runs - # with <= 12 epochs. - step_start: int | Literal["auto"] = "auto" - # "auto" uses a compressed short-run schedule for <= 12 epochs and - # transitions to the midpoint rule on longer runs. - # None means mosaic is always on. - step_stop: int | Literal["auto"] | None = "auto" - - -class DINOv2LTDETRObjectDetectionResizeArgs(ResizeArgs): - height: int | Literal["auto"] = "auto" - width: int | Literal["auto"] = "auto" - - -class DINOv2LTDETRObjectDetectionTrainTransformArgs(ObjectDetectionTransformArgs): - channel_drop: None = None - num_channels: int | Literal["auto"] = "auto" - photometric_distort: ( - DINOv2LTDETRObjectDetectionRandomPhotometricDistortArgs | None - ) = Field(default_factory=DINOv2LTDETRObjectDetectionRandomPhotometricDistortArgs) - random_zoom_out: DINOv2LTDETRObjectDetectionRandomZoomOutArgs | None = Field( - default_factory=DINOv2LTDETRObjectDetectionRandomZoomOutArgs - ) - random_iou_crop: DINOv2LTDETRObjectDetectionRandomIoUCropArgs | None = Field( - default_factory=DINOv2LTDETRObjectDetectionRandomIoUCropArgs - ) - random_flip: DINOv2LTDETRObjectDetectionRandomFlipArgs | None = Field( - default_factory=DINOv2LTDETRObjectDetectionRandomFlipArgs - ) - random_rotate_90: RandomRotate90Args | None = None - random_rotate: RandomRotationArgs | None = None - image_size: ImageSizeTuple | Literal["auto"] = "auto" - resize: ResizeArgs | None = Field( - default_factory=DINOv2LTDETRObjectDetectionResizeArgs - ) - scale_jitter: DINOv2LTDETRObjectDetectionScaleJitterArgs | None = Field( - default_factory=DINOv2LTDETRObjectDetectionScaleJitterArgs - ) - mosaic: DINOv2LTDETRObjectDetectionMosaicArgs | None = Field( - default_factory=DINOv2LTDETRObjectDetectionMosaicArgs - ) - mixup: DINOv2LTDETRObjectDetectionMixUpArgs | None = Field( - default_factory=DINOv2LTDETRObjectDetectionMixUpArgs - ) - copyblend: DINOv2LTDETRObjectDetectionCopyBlendArgs | None = Field( - default_factory=DINOv2LTDETRObjectDetectionCopyBlendArgs - ) - # We use the YOLO format internally for now. - bbox_params: BboxParams = Field( - default_factory=lambda: BboxParams( - format="yolo", - label_fields=["class_labels"], - min_area=1.0, # Bbox must have an area of at least 1 pixel. - min_width=0.0, - min_height=0.0, - **( - dict(filter_invalid_bboxes=True) - if ALBUMENTATIONS_VERSION_GREATER_EQUAL_2_0_1 - else {} - ), - **(dict(clip=True) if ALBUMENTATIONS_VERSION_GREATER_EQUAL_1_4_5 else {}), - ), - ) - normalize: NormalizeArgs | Literal["auto"] | None = "auto" - - def resolve_auto(self, model_init_args: dict[str, Any]) -> None: - super().resolve_auto(model_init_args=model_init_args) - - if self.image_size == "auto": - self.image_size = tuple(model_init_args.get("image_size", (644, 644))) - - height, width = self.image_size - for field_name in self.__class__.model_fields: - field = getattr(self, field_name) - if hasattr(field, "resolve_auto"): - field.resolve_auto(height=height, width=width) - - if self.normalize == "auto": - normalize = model_init_args.get("image_normalize", "none") - # Normalize is specifically set to None in model_init_args. - if normalize is None: - self.normalize = None - # Normalize is not set in model_init_args. - elif normalize == "none": - self.normalize = NormalizeArgs() - else: - assert isinstance(normalize, dict) - self.normalize = NormalizeArgs.from_dict(normalize) - - if self.num_channels == "auto": - if self.channel_drop is not None: - self.num_channels = self.channel_drop.num_channels_keep - else: - if self.normalize is None: - self.num_channels = 3 - else: - self.num_channels = len(self.normalize.mean) - - def resolve_step_schedule( - self, - total_steps: int, - train_num_batches: int, - gradient_accumulation_steps: int, - ) -> None: - """Resolve ``"auto"`` step_start / step_stop values. - - See :func:`resolve_ltdetr_step_schedule_for_augmentation`. - """ - resolve_ltdetr_step_schedule_for_augmentation( - args=self, - total_steps=total_steps, - train_num_batches=train_num_batches, - gradient_accumulation_steps=gradient_accumulation_steps, - ) - - -class DINOv2LTDETRObjectDetectionValTransformArgs(ObjectDetectionTransformArgs): - channel_drop: None = None - num_channels: int | Literal["auto"] = "auto" - photometric_distort: None = None - random_zoom_out: None = None - random_iou_crop: None = None - random_flip: None = None - random_rotate_90: RandomRotate90Args | None = None - random_rotate: RandomRotationArgs | None = None - image_size: ImageSizeTuple | Literal["auto"] = "auto" - resize: ResizeArgs | None = Field( - default_factory=DINOv2LTDETRObjectDetectionResizeArgs - ) - scale_jitter: ScaleJitterArgs | None = None - mosaic: DINOv2LTDETRObjectDetectionMosaicArgs | None = None - mixup: DINOv2LTDETRObjectDetectionMixUpArgs | None = None - copyblend: DINOv2LTDETRObjectDetectionCopyBlendArgs | None = None - bbox_params: BboxParams = Field( - default_factory=lambda: BboxParams( - format="yolo", - label_fields=["class_labels"], - min_width=0.0, - min_height=0.0, - **( - dict(filter_invalid_bboxes=True) - if ALBUMENTATIONS_VERSION_GREATER_EQUAL_2_0_1 - else {} - ), - **(dict(clip=True) if ALBUMENTATIONS_VERSION_GREATER_EQUAL_1_4_5 else {}), - ), - ) - normalize: NormalizeArgs | Literal["auto"] | None = "auto" - - def resolve_auto(self, model_init_args: dict[str, Any]) -> None: - super().resolve_auto(model_init_args=model_init_args) - - if self.image_size == "auto": - self.image_size = tuple(model_init_args.get("image_size", (644, 644))) - - height, width = self.image_size - for field_name in self.__class__.model_fields: - field = getattr(self, field_name) - if hasattr(field, "resolve_auto"): - field.resolve_auto(height=height, width=width) - - if self.normalize == "auto": - normalize = model_init_args.get("image_normalize", "none") - # Normalize is specifically set to None in model_init_args. - if normalize is None: - self.normalize = None - # Normalize is not set in model_init_args. - elif normalize == "none": - self.normalize = NormalizeArgs() - else: - assert isinstance(normalize, dict) - self.normalize = NormalizeArgs.from_dict(normalize) - - if self.num_channels == "auto": - if self.channel_drop is not None: - self.num_channels = self.channel_drop.num_channels_keep - else: - if self.normalize is None: - self.num_channels = 3 - else: - self.num_channels = len(self.normalize.mean) - - -class DINOv2LTDETRObjectDetectionTrainTransform(ObjectDetectionTransform): - transform_args_cls = DINOv2LTDETRObjectDetectionTrainTransformArgs - - -class DINOv2LTDETRObjectDetectionValTransform(ObjectDetectionTransform): - transform_args_cls = DINOv2LTDETRObjectDetectionValTransformArgs diff --git a/src/lightly_train/_task_models/dinov3_ltdetr_object_detection/cnn_wrapper.py b/src/lightly_train/_task_models/dinov3_ltdetr_object_detection/cnn_wrapper.py new file mode 100644 index 000000000..0c0ada49f --- /dev/null +++ b/src/lightly_train/_task_models/dinov3_ltdetr_object_detection/cnn_wrapper.py @@ -0,0 +1,56 @@ +# +# Copyright (c) Lightly AG and affiliates. +# All rights reserved. +# +# This source code is licensed under the license found in the +# LICENSE file in the root directory of this source tree. +# +from __future__ import annotations + +import logging +from typing import Any + +from torch import Tensor +from torch.nn import Module + +from lightly_train import _torch_helpers +from lightly_train._models.model_wrapper import MultiScaleFeatureCNN + +logger = logging.getLogger(__name__) + + +class CNNMultiScaleBackboneWrapper(Module): + def __init__(self, model_wrapper: MultiScaleFeatureCNN) -> None: + super().__init__() + self._model_wrapper = model_wrapper + _torch_helpers.register_load_state_dict_pre_hook( + self, CNNMultiScaleBackboneWrapper._remap_legacy_keys + ) + + @property + def backbone_model(self) -> Module: + return self._model_wrapper.get_model() # type: ignore[no-any-return] + + @staticmethod + def _remap_legacy_keys( + module: Module, + state_dict: dict[str, Any], + prefix: str, + *args: Any, + **kwargs: Any, + ) -> None: + old_subprefix = prefix + "backbone." + new_subprefix = prefix + "_model_wrapper._model." + if any(k.startswith(old_subprefix) for k in state_dict): + logger.info( + "Detected old CNNMultiScaleBackboneWrapper checkpoint format " + "(backbone. → _model_wrapper._model.). Remapping keys." + ) + for k in [ + k for k in list(state_dict.keys()) if k.startswith(old_subprefix) + ]: + state_dict[new_subprefix + k[len(old_subprefix) :]] = state_dict.pop(k) + + def forward(self, x: Tensor) -> tuple[Tensor, ...]: + feats = self._model_wrapper.forward_multiscale_features(x, [1, 2, 3]) + return tuple(f["features"] for f in feats) diff --git a/src/lightly_train/_task_models/dinov3_ltdetr_object_detection/task_model.py b/src/lightly_train/_task_models/dinov3_ltdetr_object_detection/task_model.py index 331cf03f6..be4ce638f 100644 --- a/src/lightly_train/_task_models/dinov3_ltdetr_object_detection/task_model.py +++ b/src/lightly_train/_task_models/dinov3_ltdetr_object_detection/task_model.py @@ -25,18 +25,19 @@ from lightly_train._data import file_helpers from lightly_train._export import tensorrt_helpers from lightly_train._models import package_helpers -from lightly_train._models.dinov3.dinov3_convnext import DINOv3VConvNeXtModelWrapper +from lightly_train._models.dinov2_vit.dinov2_vit_package import DINOV2_VIT_PACKAGE from lightly_train._models.dinov3.dinov3_package import DINOV3_PACKAGE -from lightly_train._models.dinov3.dinov3_src.models.convnext import ConvNeXt -from lightly_train._models.dinov3.dinov3_src.models.vision_transformer import ( - DinoVisionTransformer, +from lightly_train._models.fastvit.fastvit_package import FASTVIT_PACKAGE +from lightly_train._models.model_wrapper import ( + MultiScaleFeatureCNN, + MultiScaleFeatureViT, ) -from lightly_train._models.dinov3.dinov3_vit import DINOv3ViTModelWrapper -from lightly_train._task_models.dinov3_ltdetr_object_detection.dinov3_convnext_wrapper import ( - DINOv3ConvNextWrapper, +from lightly_train._models.package import Package +from lightly_train._task_models.dinov3_ltdetr_object_detection.cnn_wrapper import ( + CNNMultiScaleBackboneWrapper, ) -from lightly_train._task_models.dinov3_ltdetr_object_detection.dinov3_vit_wrapper import ( - DINOv3STAs, +from lightly_train._task_models.dinov3_ltdetr_object_detection.vit_wrapper import ( + ViTSTAsBackboneWrapper, ) from lightly_train._task_models.object_detection_components import tiling_utils from lightly_train._task_models.object_detection_components.dfine_decoder import ( @@ -401,6 +402,33 @@ class _RTDETRPostProcessorConfig(PydanticConfig): num_top_queries: int = 300 +class _HybridEncoderFastViTSAConfig(_HybridEncoderConfig): + in_channels: list[int] = [128, 256, 512] + feat_strides: list[int] = [8, 16, 32] + hidden_dim: int = 256 + use_encoder_idx: list[int] = [2] + num_encoder_layers: int = 1 + nhead: int = 8 + dim_feedforward: int = 1024 + dropout: float = 0.0 + enc_act: str = "gelu" + expansion: float = 1.0 + depth_mult: float = 1.0 + act: str = "silu" + + +class _RTDETRTransformerv2FastViTSAConfig(_RTDETRTransformerv2Config): + feat_channels: list[int] = [256, 256, 256] + hidden_dim: int = 256 + + +class _DFINETransformerFastViTSAConfig(_DFINETransformerConfig): + feat_channels: list[int] = [256, 256, 256] + hidden_dim: int = 256 + num_layers: int = 3 + dim_feedforward: int = 1024 + + class _DINOv3LTDETRObjectDetectionConfig(PydanticConfig): decoder_name: _LTDETRDecoderName = "rtdetrv2" hybrid_encoder: _HybridEncoderConfig @@ -562,6 +590,58 @@ class _DINOv3LTDETRObjectDetectionViTLConfig(_DINOv3LTDETRObjectDetectionConfig) ) +class _DINOv3LTDETRObjectDetectionFastViTSA12Config(_DINOv3LTDETRObjectDetectionConfig): + hybrid_encoder: _HybridEncoderFastViTSAConfig = Field( + default_factory=_HybridEncoderFastViTSAConfig + ) + rtdetr_transformer: _RTDETRTransformerv2FastViTSAConfig = Field( + default_factory=_RTDETRTransformerv2FastViTSAConfig + ) + dfine_transformer: _DFINETransformerFastViTSAConfig = Field( + default_factory=_DFINETransformerFastViTSAConfig + ) + rtdetr_postprocessor: _RTDETRPostProcessorConfig = Field( + default_factory=_RTDETRPostProcessorConfig + ) + + +class _DINOv3LTDETRObjectDetectionFastViTSA24Config(_DINOv3LTDETRObjectDetectionConfig): + hybrid_encoder: _HybridEncoderFastViTSAConfig = Field( + default_factory=_HybridEncoderFastViTSAConfig + ) + rtdetr_transformer: _RTDETRTransformerv2FastViTSAConfig = Field( + default_factory=_RTDETRTransformerv2FastViTSAConfig + ) + dfine_transformer: _DFINETransformerFastViTSAConfig = Field( + default_factory=_DFINETransformerFastViTSAConfig + ) + rtdetr_postprocessor: _RTDETRPostProcessorConfig = Field( + default_factory=_RTDETRPostProcessorConfig + ) + + +class _DINOv3LTDETRObjectDetectionFastViTSA36Config(_DINOv3LTDETRObjectDetectionConfig): + hybrid_encoder: _HybridEncoderFastViTSAConfig = Field( + default_factory=_HybridEncoderFastViTSAConfig + ) + rtdetr_transformer: _RTDETRTransformerv2FastViTSAConfig = Field( + default_factory=_RTDETRTransformerv2FastViTSAConfig + ) + dfine_transformer: _DFINETransformerFastViTSAConfig = Field( + default_factory=_DFINETransformerFastViTSAConfig + ) + rtdetr_postprocessor: _RTDETRPostProcessorConfig = Field( + default_factory=_RTDETRPostProcessorConfig + ) + + +_COMPATIBLE_PACKAGES: list[Package] = [ + DINOV3_PACKAGE, + DINOV2_VIT_PACKAGE, + FASTVIT_PACKAGE, +] + + class DINOv3LTDETRObjectDetection(TaskModel): model_suffix = "ltdetr" @@ -643,26 +723,30 @@ def __init__( # NOTE(Guarin, 08/25): We don't set drop_path_rate=0 here because it is already # set by DINOv3. - backbone_model_args: dict[str, Any] = { - "patch_size": patch_size, - } + backbone_model_args: dict[str, Any] = {} + # patch_size is a DINOv3-specific constructor argument; other packages derive + # the patch size from the model architecture. + if parsed_name["package_name"] == DINOV3_PACKAGE.name: + backbone_model_args["patch_size"] = patch_size if backbone_args is not None: backbone_model_args.update(backbone_args) if backbone_weights is not None: backbone_model_args["weights"] = str(backbone_weights) - get_model_kwargs = {} - if self.image_normalize is not None: - get_model_kwargs["num_input_channels"] = len(self.image_normalize["mean"]) - - # Get the backbone. - backbone = DINOV3_PACKAGE.get_model( - model_name=parsed_name["backbone_name"], + # Get the backbone wrapper (protocol-based, works for any compatible package). + model_wrapper = package_helpers.get_wrapped_model( + model=f"{parsed_name['package_name']}/{parsed_name['backbone_name']}", + num_input_channels=self._expected_input_channels, model_args=backbone_model_args, load_weights=load_weights, - **get_model_kwargs, ) - assert isinstance(backbone, (ConvNeXt, DinoVisionTransformer)) + if not isinstance(model_wrapper, (MultiScaleFeatureViT, MultiScaleFeatureCNN)): + raise ValueError( + f"Backbone '{parsed_name['backbone_name']}' from package " + f"'{parsed_name['package_name']}' does not implement multi-scale " + "feature extraction (MultiScaleFeatureViT or MultiScaleFeatureCNN) " + "required by LT-DETR." + ) config_mapping = { "vitt16": _DINOv3LTDETRObjectDetectionViTTConfig, @@ -674,34 +758,53 @@ def __init__( "convnext-small": _DINOv3LTDETRObjectDetectionSmallConfig, "convnext-base": _DINOv3LTDETRObjectDetectionBaseConfig, "convnext-large": _DINOv3LTDETRObjectDetectionLargeConfig, + "fastvit_sa12": _DINOv3LTDETRObjectDetectionFastViTSA12Config, + "fastvit_sa24": _DINOv3LTDETRObjectDetectionFastViTSA24Config, + "fastvit_sa36": _DINOv3LTDETRObjectDetectionFastViTSA36Config, } config_name = parsed_name["backbone_name"].replace("-notpretrained", "") config_name = config_name.replace("-noreg", "") config_name = config_name.replace("-eupe", "") - config_cls = config_mapping[config_name] - config = config_cls() + if config_name in config_mapping: + config = config_mapping[config_name]() + vit_wrapper_kwargs: dict = ( + config.backbone_wrapper.model_dump() + if isinstance(model_wrapper, MultiScaleFeatureViT) + else {} + ) + else: + raise ValueError( + f"Backbone '{parsed_name['backbone_name']}' from package " + f"'{parsed_name['package_name']}' is not supported by LT-DETR. " + f"Supported backbones: {list(config_mapping)}." + ) config.decoder_name = decoder_name - config.resolve_auto(patch_size=patch_size) + # For ViT backbones, derive patch_size from the model wrapper itself so that + # non-DINOv3 backbones (which don't accept patch_size as a constructor arg) + # still resolve strides correctly. + resolved_patch_size = ( + model_wrapper.patch_size() + if isinstance(model_wrapper, MultiScaleFeatureViT) + else patch_size + ) + config.resolve_auto(patch_size=resolved_patch_size) - self.backbone: DINOv3STAs | DINOv3ConvNextWrapper + self.backbone: ViTSTAsBackboneWrapper | CNNMultiScaleBackboneWrapper - if isinstance(backbone, DinoVisionTransformer): - # TODO(Guarin, 02/26): Improve how mask tokens are handled for fine-tuning. - backbone.mask_token.requires_grad = False # type: ignore + # Disable mask token gradient for models that use them (e.g. DINOv3 ViT). + # TODO(Guarin, 02/26): Improve how mask tokens are handled for fine-tuning. + underlying = model_wrapper.get_model() + if hasattr(underlying, "mask_token") and underlying.mask_token is not None: + underlying.mask_token.requires_grad = False - # ViT models. - vit_model_wrapper = DINOv3ViTModelWrapper(backbone) - self.backbone = DINOv3STAs( - model_wrapper=vit_model_wrapper, - **config.backbone_wrapper.model_dump(), + if isinstance(model_wrapper, MultiScaleFeatureViT): + self.backbone = ViTSTAsBackboneWrapper( + model_wrapper=model_wrapper, + **vit_wrapper_kwargs, ) - else: - # ConvNext models. - assert isinstance(backbone, ConvNeXt) - convnext_model_wrapper = DINOv3VConvNeXtModelWrapper(backbone) - self.backbone = DINOv3ConvNextWrapper(model_wrapper=convnext_model_wrapper) + self.backbone = CNNMultiScaleBackboneWrapper(model_wrapper=model_wrapper) self.encoder: HybridEncoder = HybridEncoder( **config.hybrid_encoder.model_dump() @@ -726,7 +829,9 @@ def __init__( @classmethod def list_model_names(cls) -> list[str]: return [ - f"{name}-{cls.model_suffix}" for name in DINOV3_PACKAGE.list_model_names() + f"{name}-{cls.model_suffix}" + for pkg in _COMPATIBLE_PACKAGES + for name in pkg.list_model_names() ] @classmethod @@ -758,16 +863,25 @@ def raise_invalid_name() -> None: except ValueError: raise_invalid_name() - if package_name != DINOV3_PACKAGE.name: - raise_invalid_name() - try: - backbone_name = DINOV3_PACKAGE.parse_model_name(model_name=backbone_name) + pkg = package_helpers.get_package(package_name) except ValueError: raise_invalid_name() + if pkg not in _COMPATIBLE_PACKAGES: + raise_invalid_name() + + # Normalize the backbone name if the package supports it (e.g. DINOv3, DINOv2 + # strip variant suffixes like -notpretrained, -noreg, etc.). + if hasattr(pkg, "parse_model_name"): + try: + backbone_name = pkg.parse_model_name(model_name=backbone_name) + except ValueError: + raise_invalid_name() + return { - "model_name": f"{DINOV3_PACKAGE.name}/{backbone_name}-{cls.model_suffix}", + "model_name": f"{package_name}/{backbone_name}-{cls.model_suffix}", + "package_name": package_name, "backbone_name": backbone_name, } diff --git a/src/lightly_train/_task_models/dinov3_ltdetr_object_detection/train_model.py b/src/lightly_train/_task_models/dinov3_ltdetr_object_detection/train_model.py index cdb42d98c..0c8c63ebf 100644 --- a/src/lightly_train/_task_models/dinov3_ltdetr_object_detection/train_model.py +++ b/src/lightly_train/_task_models/dinov3_ltdetr_object_detection/train_model.py @@ -35,9 +35,6 @@ ObjectDetectionTaskMetricArgs, ) from lightly_train._optim import optimizer_helpers -from lightly_train._task_models.dinov3_ltdetr_object_detection.dinov3_vit_wrapper import ( - DINOv3STAs, -) from lightly_train._task_models.dinov3_ltdetr_object_detection.task_model import ( DINOv3LTDETRObjectDetection, ) @@ -47,6 +44,9 @@ DINOv3LTDETRObjectDetectionValTransform, DINOv3LTDETRObjectDetectionValTransformArgs, ) +from lightly_train._task_models.dinov3_ltdetr_object_detection.vit_wrapper import ( + ViTSTAsBackboneWrapper, +) from lightly_train._task_models.object_detection_components.dfine_criterion import ( DFINECriterion, ) @@ -177,6 +177,8 @@ def resolve_auto( self.patch_size = int(match.group("patch_size")) elif re.match(r"dinov3/convnext.*", model_name) is not None: self.patch_size = None + elif re.match(r"fastvit/.*", model_name) is not None: + self.patch_size = None else: raise ValueError( "Unable to resolve patch_size='auto' for model " @@ -545,7 +547,7 @@ def get_optimizer( backbone_lr = lr * self.model_args.backbone_lr_factor backbone = self.model.backbone - if isinstance(backbone, DINOv3STAs): + if isinstance(backbone, ViTSTAsBackboneWrapper): # Only the pretrained ViT gets the low backbone LR. backbone_params = list(backbone.backbone_model.parameters()) # The connector modules (sta, convs, norms) are randomly initialized and diff --git a/src/lightly_train/_task_models/dinov3_ltdetr_object_detection/transforms.py b/src/lightly_train/_task_models/dinov3_ltdetr_object_detection/transforms.py index 98a2f648c..5688b5e4b 100644 --- a/src/lightly_train/_task_models/dinov3_ltdetr_object_detection/transforms.py +++ b/src/lightly_train/_task_models/dinov3_ltdetr_object_detection/transforms.py @@ -329,7 +329,7 @@ def resolve_auto(self, model_init_args: dict[str, Any]) -> None: # map and we make a multi-scale from it with the next scales # (H/2)x(W/2), (H)x(W) and (2H)x(2W). That's why we need it to be divisible_by # 2*patch_size, to account for this 2x smaller feature map. - # You can take a look at the forward of the DINOv3STAs class. + # You can take a look at the forward of the ViTSTAsBackboneWrapper class. self.scale_jitter.divisible_by = ltdetr_image_size_divisor( patch_size ) diff --git a/src/lightly_train/_task_models/dinov2_ltdetr_object_detection/dinov2_vit_wrapper.py b/src/lightly_train/_task_models/dinov3_ltdetr_object_detection/vit_wrapper.py similarity index 82% rename from src/lightly_train/_task_models/dinov2_ltdetr_object_detection/dinov2_vit_wrapper.py rename to src/lightly_train/_task_models/dinov3_ltdetr_object_detection/vit_wrapper.py index 9e101200c..08799280c 100644 --- a/src/lightly_train/_task_models/dinov2_ltdetr_object_detection/dinov2_vit_wrapper.py +++ b/src/lightly_train/_task_models/dinov3_ltdetr_object_detection/vit_wrapper.py @@ -1,15 +1,11 @@ # -# Licensed under the Apache License, Version 2.0 (the "License"); -# you may not use this file except in compliance with the License. -# You may obtain a copy of the License at +# Copyright (c) Lightly AG and affiliates. +# All rights reserved. # -# http://www.apache.org/licenses/LICENSE-2.0 +# This source code is licensed under the license found in the +# LICENSE file in the root directory of this source tree. # -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, -# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -# See the License for the specific language governing permissions and -# limitations under the License.# + """ DEIMv2: Real-Time Object Detection Meets DINOv3 Copyright (c) 2025 The DEIMv2 Authors. All Rights Reserved. @@ -48,7 +44,7 @@ ) from lightly_train import _torch_helpers -from lightly_train._models.dinov2_vit.dinov2_vit import DINOv2ViTModelWrapper +from lightly_train._models.model_wrapper import MultiScaleFeatureViT logger = logging.getLogger(__name__) @@ -120,10 +116,10 @@ def forward(self, x: Tensor) -> tuple[Tensor, Tensor, Tensor]: return c2, c3, c4 -class DINOv2STAs(Module): +class ViTSTAsBackboneWrapper(Module): def __init__( self, - model_wrapper: DINOv2ViTModelWrapper, + model_wrapper: MultiScaleFeatureViT, interaction_indexes: list[int] = [5, 8, 11], finetune: bool = True, use_sta: bool = True, @@ -137,21 +133,14 @@ def __init__( assert len(interaction_indexes) == 3 self.interaction_indexes = interaction_indexes - self.patch_size = model_wrapper.get_model().patch_size - - if use_sta and self.patch_size != 16: - raise ValueError( - f"use_sta=True requires patch_size=16, but got patch_size={self.patch_size}. " - "SpatialPriorModulev2 extracts features at strides H/8, H/16, H/32, which only " - "aligns with ViT patch grids when patch_size=16." - ) + self.patch_size = model_wrapper.patch_size() if not finetune: model_wrapper.eval() model_wrapper.requires_grad_(False) _torch_helpers.register_load_state_dict_pre_hook( - self, DINOv2STAs._remap_legacy_keys + self, ViTSTAsBackboneWrapper._remap_legacy_keys ) # init the feature pyramid @@ -202,7 +191,7 @@ def __init__( @property def backbone_model(self) -> Module: - return self._model_wrapper.get_model() + return self._model_wrapper.get_model() # type: ignore[no-any-return] @staticmethod def _remap_legacy_keys( @@ -212,12 +201,12 @@ def _remap_legacy_keys( *args: Any, **kwargs: Any, ) -> None: - old_subprefix = prefix + "dinov2." + old_subprefix = prefix + "dinov3." new_subprefix = prefix + "_model_wrapper._model." if any(k.startswith(old_subprefix) for k in state_dict): logger.info( - "Detected old DINOv2STAs checkpoint format " - "(dinov2. → _model_wrapper._model.). Remapping keys." + "Detected old ViTSTAsBackboneWrapper checkpoint format " + "(dinov3. → _model_wrapper._model.). Remapping keys." ) for k in [ k for k in list(state_dict.keys()) if k.startswith(old_subprefix) @@ -253,7 +242,21 @@ def forward(self, x: Tensor) -> tuple[Tensor, Tensor, Tensor]: if self.use_sta: detail_feats = self.sta(x) for semantic_feat, detail_feat in zip(resized_feats, detail_feats): - fused_feats.append(torch.cat([semantic_feat, detail_feat], dim=1)) + detail_feat_interpolated = F.interpolate( + detail_feat, + size=semantic_feat.shape[-2:], + mode="bilinear", + align_corners=False, + ) + fused_feats.append( + torch.cat( + [ + semantic_feat, + detail_feat_interpolated, + ], + dim=1, + ) + ) else: fused_feats = resized_feats diff --git a/src/lightly_train/_task_models/task_model_helpers.py b/src/lightly_train/_task_models/task_model_helpers.py index 8dba1289d..ea6f61f68 100644 --- a/src/lightly_train/_task_models/task_model_helpers.py +++ b/src/lightly_train/_task_models/task_model_helpers.py @@ -39,14 +39,6 @@ # model name, file name, and hash. DOWNLOADABLE_MODEL_URL_AND_HASH: dict[str, tuple[str, str]] = { #### Object Detection - "dinov2/vits14-noreg-ltdetr-coco": ( - "dinov2_vits14_noreg_ltdetr_coco_251218_4e1f523d.pt", - "4e1f523db68c94516ee5b35a91f24267657af474bea58b52a7f7e51ec2d8f717", - ), - "dinov2/vits14-ltdetr-dsp-coco": ( - "dinov2_vits14_ltdetr_dsp_coco_251218_fa435184.pt", - "fa435184c775205469056f46456941ea271266ee522c656642853d061317f8ae", - ), "dinov3/vitt16-ltdetr-coco": ( "dinov3_vitt16_ltdetr_coco_251218_dfd34210.pt", "dfd34210a1a3375793d149a55d9b49e6e8b783458bdd4cd76fd28fa2d61dbb37", diff --git a/tests/_commands/test_train_task.py b/tests/_commands/test_train_task.py index 5c695f921..0e3c169a5 100644 --- a/tests/_commands/test_train_task.py +++ b/tests/_commands/test_train_task.py @@ -203,7 +203,7 @@ def test_train_object_detection_yolo(tmp_path: Path) -> None: # Check training lightly_train.train_object_detection( out=out, - model="dinov3/vitt16-notpretrained-ltdetr", + model="fastvit/fastvit_sa12-ltdetr", data={ "path": data, "train": Path("train", "images"), diff --git a/tests/_models/fastvit/__init__.py b/tests/_models/fastvit/__init__.py new file mode 100644 index 000000000..80cae297b --- /dev/null +++ b/tests/_models/fastvit/__init__.py @@ -0,0 +1,7 @@ +# +# Copyright (c) Lightly AG and affiliates. +# All rights reserved. +# +# This source code is licensed under the license found in the +# LICENSE file in the root directory of this source tree. +# diff --git a/tests/_task_models/dinov2_ltdetr_object_detection/test_dinov2_vit_wrapper.py b/tests/_models/fastvit/test_dinov2_vit_wrapper.py similarity index 100% rename from tests/_task_models/dinov2_ltdetr_object_detection/test_dinov2_vit_wrapper.py rename to tests/_models/fastvit/test_dinov2_vit_wrapper.py diff --git a/tests/_models/fastvit/test_fastvit_wrapper.py b/tests/_models/fastvit/test_fastvit_wrapper.py new file mode 100644 index 000000000..39d06aa38 --- /dev/null +++ b/tests/_models/fastvit/test_fastvit_wrapper.py @@ -0,0 +1,99 @@ +# +# Copyright (c) Lightly AG and affiliates. +# All rights reserved. +# +# This source code is licensed under the license found in the +# LICENSE file in the root directory of this source tree. +# +from __future__ import annotations + +import pytest +import torch + +from lightly_train._models.fastvit.fastvit import FastViTModelWrapper + +from ...helpers import dummy_fastvit_model + + +@pytest.fixture +def wrapper() -> FastViTModelWrapper: + return dummy_fastvit_model() + + +class TestFastViTModelWrapper: + def test_multiscale_feature_dims(self, wrapper: FastViTModelWrapper) -> None: + dims = wrapper.multiscale_feature_dims() + assert len(dims) == 4 + # fastvit_t8 has embed_dims = [48, 96, 192, 384] + assert dims == [48, 96, 192, 384] + + def test_multiscale_feature_dims__cached( + self, wrapper: FastViTModelWrapper + ) -> None: + dims1 = wrapper.multiscale_feature_dims() + dims2 = wrapper.multiscale_feature_dims() + assert dims1 is dims2 + + def test_multiscale_feature_strides(self, wrapper: FastViTModelWrapper) -> None: + strides = wrapper.multiscale_feature_strides() + assert len(strides) == 4 + assert strides == [4, 8, 16, 32] + + def test_multiscale_feature_strides__cached( + self, wrapper: FastViTModelWrapper + ) -> None: + strides1 = wrapper.multiscale_feature_strides() + strides2 = wrapper.multiscale_feature_strides() + assert strides1 is strides2 + + def test_forward_multiscale_features__all_stages( + self, wrapper: FastViTModelWrapper + ) -> None: + x = torch.randn(1, 3, 64, 64) + feats = wrapper.forward_multiscale_features(x, [0, 1, 2, 3]) + assert len(feats) == 4 + + dims = wrapper.multiscale_feature_dims() + strides = wrapper.multiscale_feature_strides() + for i, feat in enumerate(feats): + assert "features" in feat + assert feat["features"].shape[1] == dims[i] + expected_h = 64 // strides[i] + expected_w = 64 // strides[i] + assert feat["features"].shape[-2:] == (expected_h, expected_w) + + def test_forward_multiscale_features__subset( + self, wrapper: FastViTModelWrapper + ) -> None: + x = torch.randn(2, 3, 64, 64) + feats = wrapper.forward_multiscale_features(x, [1, 3]) + assert len(feats) == 2 + + dims = wrapper.multiscale_feature_dims() + strides = wrapper.multiscale_feature_strides() + assert feats[0]["features"].shape == ( + 2, + dims[1], + 64 // strides[1], + 64 // strides[1], + ) + assert feats[1]["features"].shape == ( + 2, + dims[3], + 64 // strides[3], + 64 // strides[3], + ) + + def test_forward_multiscale_features__invalid_index_raises( + self, wrapper: FastViTModelWrapper + ) -> None: + x = torch.randn(1, 3, 64, 64) + with pytest.raises(AssertionError): + wrapper.forward_multiscale_features(x, [4]) + + def test_forward_multiscale_features__negative_index_raises( + self, wrapper: FastViTModelWrapper + ) -> None: + x = torch.randn(1, 3, 64, 64) + with pytest.raises(AssertionError): + wrapper.forward_multiscale_features(x, [-1]) diff --git a/tests/_task_models/dinov2_ltdetr_object_detection/test_task_model.py b/tests/_task_models/dinov2_ltdetr_object_detection/test_task_model.py deleted file mode 100644 index aac4ea4ca..000000000 --- a/tests/_task_models/dinov2_ltdetr_object_detection/test_task_model.py +++ /dev/null @@ -1,217 +0,0 @@ -# -# Copyright (c) Lightly AG and affiliates. -# All rights reserved. -# -# This source code is licensed under the license found in the -# LICENSE file in the root directory of this source tree. -# -from __future__ import annotations - -import logging -from pathlib import Path -from typing import Literal - -import pytest -import torch -from pytest_mock import MockerFixture -from torch import nn -from torch.optim.lr_scheduler import LinearLR - -from lightly_train._data.yolo_object_detection_dataset import ( - YOLOObjectDetectionDataArgs, -) -from lightly_train._metrics.detection.task_metric import ObjectDetectionTaskMetricArgs -from lightly_train._task_models.dinov2_ltdetr_object_detection.task_model import ( - DINOv2LTDETRObjectDetection, -) -from lightly_train._task_models.dinov2_ltdetr_object_detection.train_model import ( - DINOv2LTDETRObjectDetectionTrain, - DINOv2LTDETRObjectDetectionTrainArgs, -) -from lightly_train._task_models.dinov2_ltdetr_object_detection.transforms import ( - DINOv2LTDETRObjectDetectionTrainTransformArgs, - DINOv2LTDETRObjectDetectionValTransformArgs, -) -from lightly_train._task_models.object_detection_components.flat_cosine import ( - FlatCosineLRScheduler, -) - - -@pytest.mark.parametrize("use_ema_model", [True, False]) -def test_load_train_state_dict__from_exported(use_ema_model: bool) -> None: - model_args = DINOv2LTDETRObjectDetectionTrainArgs(use_ema_model=use_ema_model) - train_model = _create_train_model(model_args) - task_model = train_model.model - state_dict = train_model.get_export_state_dict() - task_model.load_train_state_dict(state_dict) - - -def test_load_train_state_dict__no_ema_weights() -> None: - model_args = DINOv2LTDETRObjectDetectionTrainArgs(use_ema_model=True) - train_model = _create_train_model(model_args) - task_model = train_model.model - state_dict = train_model.state_dict() - # Drop all EMA weights from the state dict. This is for backwards compatibility - # with older checkpoints. The model should still be able to load the weights by - # copying the non-EMA weights to the EMA model. - state_dict = {k: v for k, v in state_dict.items() if not k.startswith("ema_model.")} - task_model.load_train_state_dict(state_dict) - - -def _is_module_frozen(m: nn.Module) -> bool: - return all(not param.requires_grad for param in m.parameters()) - - -@pytest.mark.parametrize("should_freeze", [True, False]) -def test_freeze_backbone_on_set_train_mode(should_freeze: bool) -> None: - model_args = DINOv2LTDETRObjectDetectionTrainArgs( - use_ema_model=True, backbone_freeze=should_freeze - ) - train_model = _create_train_model(model_args) - task_model_backbone = train_model.model.backbone - assert isinstance(task_model_backbone, nn.Module), "Backbone should be a nn.Module" - - train_model.set_train_mode() - - assert _is_module_frozen(task_model_backbone) == should_freeze, ( - f"Backbone should be frozen: {should_freeze}, but got frozen={_is_module_frozen(task_model_backbone)}" - ) - assert not task_model_backbone.training == should_freeze, ( - "Backbone should be in eval mode after set_train_mode()" - ) - - -def _create_train_model( - train_model_args: DINOv2LTDETRObjectDetectionTrainArgs, -) -> DINOv2LTDETRObjectDetectionTrain: - data_args = YOLOObjectDetectionDataArgs( - path=Path("/tmp/data"), - train=Path("train") / "images", - val=Path("val") / "images", - names={0: "class_0", 1: "class_1"}, - ) - train_model_args.resolve_auto( - total_steps=1000, - gradient_accumulation_steps=1, - train_num_batches=100, - model_name="dinov2/_vittest14-ltdetr", - model_init_args={}, - data_args=data_args, - ) - train_transform_args = DINOv2LTDETRObjectDetectionTrainTransformArgs() - train_transform_args.resolve_auto(model_init_args={}) - val_transform_args = DINOv2LTDETRObjectDetectionValTransformArgs() - val_transform_args.resolve_auto(model_init_args={}) - - train_model = DINOv2LTDETRObjectDetectionTrain( - model_name="dinov2/_vittest14-ltdetr", - model_args=train_model_args, - data_args=data_args, - train_transform_args=train_transform_args, - val_transform_args=val_transform_args, - metric_args=ObjectDetectionTaskMetricArgs(), - load_weights=False, - gradient_accumulation_steps=1, - ) - return train_model - - -@pytest.mark.parametrize( - ("scheduler_name", "scheduler_cls"), - [ - ("linear", LinearLR), - ("flat-cosine", FlatCosineLRScheduler), - ], -) -def test_get_optimizer__scheduler_modes( - scheduler_name: Literal["linear", "flat-cosine"], - scheduler_cls: type[LinearLR] | type[FlatCosineLRScheduler], -) -> None: - train_model = _create_train_model( - DINOv2LTDETRObjectDetectionTrainArgs( - scheduler_name=scheduler_name, - lr_warmup_steps=500, - scheduler_flat_steps=550, - scheduler_no_aug_steps=150, - ) - ) - optimizer, scheduler = train_model.get_optimizer( - total_steps=1000, - global_batch_size=16, - ) - - assert isinstance(scheduler, scheduler_cls) - optimizer.step() - scheduler.step() - assert len(scheduler.get_last_lr()) == len(optimizer.param_groups) - scheduler.load_state_dict(scheduler.state_dict()) # type: ignore[no-untyped-call] - - -def test_get_optimizer__flat_cosine_raises_when_cosine_phase_collapses() -> None: - train_model = _create_train_model( - DINOv2LTDETRObjectDetectionTrainArgs( - scheduler_name="flat-cosine", - lr_warmup_steps=1000, - ) - ) - - with pytest.raises(ValueError, match="non-empty cosine phase"): - train_model.get_optimizer(total_steps=1000, global_batch_size=16) - - -def test_get_optimizer__linear_warns_when_warmup_exceeds_training( - caplog: pytest.LogCaptureFixture, -) -> None: - train_model = _create_train_model( - DINOv2LTDETRObjectDetectionTrainArgs( - scheduler_name="linear", - lr_warmup_steps=1001, - ) - ) - - with caplog.at_level( - logging.WARNING, - logger="lightly_train._task_models.dinov2_ltdetr_object_detection.train_model", - ): - train_model.get_optimizer(total_steps=1000, global_batch_size=16) - - assert "the schedule will not complete as intended" in caplog.text - - -def test_predict_batch__composes_stages_in_order(mocker: MockerFixture) -> None: - model = DINOv2LTDETRObjectDetection( - model_name="dinov2/vits14-ltdetr", - classes={0: "class_0", 1: "class_1"}, - image_size=(224, 224), - load_weights=False, - ) - - preprocess_image_spy = mocker.spy(model, "preprocess_image") - preprocess_batch_spy = mocker.spy(model, "preprocess_batch") - forward_backend_spy = mocker.spy(model, "forward_backend") - postprocess_spy = mocker.spy(model, "postprocess") - - images = [torch.rand(3, 480, 640), torch.rand(3, 720, 1280)] - result = model.predict_batch(images=images) - - # Each input image goes through preprocess_image once. - assert preprocess_image_spy.call_count == 2 - - # The stacked batch is preprocessed in a single call with shape (B, C, H, W). - assert preprocess_batch_spy.call_count == 1 - (batch_in,) = preprocess_batch_spy.call_args.args - assert batch_in.shape == (2, 3, 224, 224) - - # forward_backend receives the output of preprocess_batch. - assert forward_backend_spy.call_count == 1 - (forward_in,) = forward_backend_spy.call_args.args - assert forward_in is preprocess_batch_spy.spy_return - - # postprocess receives forward_backend's output and per-image metadata. - assert postprocess_spy.call_count == 1 - raw_in, metadata = postprocess_spy.call_args.args - assert raw_in is forward_backend_spy.spy_return - assert len(metadata) == 2 - - # predict_batch returns whatever postprocess produced. - assert result is postprocess_spy.spy_return diff --git a/tests/helpers.py b/tests/helpers.py index ab66d9610..a5b1aaf43 100644 --- a/tests/helpers.py +++ b/tests/helpers.py @@ -48,6 +48,7 @@ ) from lightly_train._models.dinov3.dinov3_vit import DINOv3ViTModelWrapper from lightly_train._models.embedding_model import EmbeddingModel +from lightly_train._models.fastvit.fastvit import FastViTModelWrapper from lightly_train._models.model_wrapper import ( ArchitectureInfo, ArchitectureInfoGettable, @@ -1076,3 +1077,10 @@ def dummy_dinov3_vit_model(patch_size: int = 2, **kwargs: Any) -> DINOv3ViTModel def dummy_dinov3_convnext_model(**kwargs: Any) -> DINOv3VConvNeXtModelWrapper: return DINOv3VConvNeXtModelWrapper(model=_dinov3_convnext_test(**kwargs)) + + +def dummy_fastvit_model(**kwargs: Any) -> FastViTModelWrapper: + from lightly_train._models.fastvit.components.models.fastvit import fastvit_t8 + + model = fastvit_t8(pretrained=False, **kwargs) + return FastViTModelWrapper(model=model) diff --git a/uv.lock b/uv.lock index 2828e7c18..519f09088 100644 --- a/uv.lock +++ b/uv.lock @@ -386,9 +386,6 @@ conflicts = [[ { package = "lightly-train", group = "pinned-torch-minimal" }, ]] -[options] -exclude-newer = "2026-05-18T22:00:00Z" - [manifest] overrides = [ { name = "onnx", specifier = ">=1.15.0" }, @@ -2572,8 +2569,8 @@ resolution-markers = [ ] dependencies = [ { name = "numpy", version = "1.23.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.12' or (extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal')" }, - { name = "opencv-python-headless", version = "4.7.0.72", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version == '3.9.*' or python_full_version == '3.11.*' or (python_full_version == '3.10.*' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version < '3.9' and extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version < '3.9' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version < '3.9' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version < '3.9' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version < '3.9' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version < '3.9' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.12' and extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version >= '3.12' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version >= '3.12' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version >= '3.12' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.12' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.12' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version == '3.10.*' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version == '3.10.*' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version == '3.10.*' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal')" }, - { name = "opencv-python-headless", version = "4.10.0.84", source = { registry = "https://pypi.org/simple" }, marker = "(python_full_version == '3.10.*' and extra == 'extra-13-lightly-train-onnx') or (python_full_version == '3.10.*' and extra == 'extra-13-lightly-train-onnxruntime') or (python_full_version == '3.10.*' and extra == 'extra-13-lightly-train-rfdetr') or (python_full_version == '3.10.*' and extra != 'extra-13-lightly-train-super-gradients') or (python_full_version != '3.10.*' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version != '3.10.*' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version != '3.10.*' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (extra == 'extra-13-lightly-train-onnx' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (extra == 'extra-13-lightly-train-onnx' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (extra == 'extra-13-lightly-train-onnx' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (extra == 'extra-13-lightly-train-onnxruntime' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (extra == 'extra-13-lightly-train-onnxruntime' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (extra == 'extra-13-lightly-train-onnxruntime' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (extra == 'extra-13-lightly-train-rfdetr' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (extra == 'extra-13-lightly-train-rfdetr' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (extra == 'extra-13-lightly-train-rfdetr' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (extra == 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (extra == 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (extra == 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal')" }, + { name = "opencv-python-headless", version = "4.7.0.72", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version == '3.9.*' or python_full_version == '3.11.*' or (python_full_version < '3.9' and extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version < '3.9' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version < '3.9' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version < '3.9' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version < '3.9' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version < '3.9' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version == '3.10.*' and extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version == '3.10.*' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version == '3.10.*' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version == '3.10.*' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version == '3.10.*' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version == '3.10.*' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.12' and extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version >= '3.12' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version >= '3.12' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version >= '3.12' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.12' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.12' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal')" }, + { name = "opencv-python-headless", version = "4.10.0.84", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version == '3.10.*' or (extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal')" }, { name = "opencv-python-headless", version = "4.13.0.92", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.9' or (extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal')" }, { name = "pyyaml", marker = "python_full_version < '3.12' or (extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal')" }, { name = "qudida", marker = "python_full_version < '3.12' or (extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal')" }, @@ -9342,7 +9339,7 @@ name = "cuda-bindings" version = "13.2.0" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "cuda-pathfinder", marker = "(python_full_version >= '3.10' and python_full_version < '3.12' and extra == 'group-13-lightly-train-minimal-torch') or (python_full_version >= '3.10' and python_full_version < '3.12' and extra != 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version < '3.10' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version < '3.10' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version < '3.10' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.12' and extra == 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch') or (python_full_version >= '3.12' and extra == 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.12' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.12' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (extra != 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal')" }, + { name = "cuda-pathfinder", marker = "(python_full_version >= '3.10' and python_full_version < '3.12' and sys_platform == 'linux' and extra == 'group-13-lightly-train-minimal-torch') or (python_full_version >= '3.10' and python_full_version < '3.12' and sys_platform == 'linux' and extra != 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version < '3.12' and sys_platform != 'linux' and extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version < '3.12' and sys_platform != 'linux' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version < '3.12' and sys_platform != 'linux' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version < '3.12' and sys_platform != 'linux' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version < '3.12' and sys_platform != 'linux' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version < '3.12' and sys_platform != 'linux' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.12' and sys_platform != 'win32' and extra == 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch') or (python_full_version >= '3.12' and sys_platform != 'win32' and extra == 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version < '3.10' and sys_platform == 'linux' and extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version < '3.10' and sys_platform == 'linux' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version < '3.10' and sys_platform == 'linux' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version < '3.10' and sys_platform == 'linux' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version < '3.10' and sys_platform == 'linux' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version < '3.10' and sys_platform == 'linux' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.12' and sys_platform == 'linux' and extra == 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch') or (python_full_version >= '3.12' and sys_platform == 'linux' and extra == 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.10' and extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version >= '3.10' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version >= '3.10' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version >= '3.12' and extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version >= '3.12' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version >= '3.12' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version >= '3.12' and extra == 'extra-13-lightly-train-onnx' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.12' and extra == 'extra-13-lightly-train-onnx' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.12' and extra == 'extra-13-lightly-train-onnx' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.12' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.12' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.12' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.12' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.12' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.12' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.10' and extra != 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.12' and extra != 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.12' and extra != 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.12' and extra != 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (sys_platform == 'win32' and extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (sys_platform == 'win32' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (sys_platform == 'win32' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (sys_platform == 'win32' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (sys_platform == 'win32' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (sys_platform == 'win32' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal')" }, ] wheels = [ { url = "https://files.pythonhosted.org/packages/1a/fe/7351d7e586a8b4c9f89731bfe4cf0148223e8f9903ff09571f78b3fb0682/cuda_bindings-13.2.0-cp310-cp310-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:08b395f79cb89ce0cd8effff07c4a1e20101b873c256a1aeb286e8fd7bd0f556", size = 5744254, upload-time = "2026-03-11T00:12:29.798Z" }, @@ -9377,34 +9374,34 @@ wheels = [ [package.optional-dependencies] cudart = [ - { name = "nvidia-cuda-runtime", marker = "(python_full_version >= '3.10' and python_full_version < '3.12' and sys_platform == 'linux' and extra == 'group-13-lightly-train-minimal-torch') or (python_full_version >= '3.10' and python_full_version < '3.12' and sys_platform == 'linux' and extra != 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.10' and python_full_version < '3.12' and sys_platform == 'win32' and extra == 'group-13-lightly-train-minimal-torch') or (python_full_version >= '3.10' and python_full_version < '3.12' and sys_platform == 'win32' and extra != 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version < '3.10' and sys_platform == 'linux' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version < '3.10' and sys_platform == 'linux' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version < '3.10' and sys_platform == 'linux' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.12' and sys_platform == 'linux' and extra == 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch') or (python_full_version >= '3.12' and sys_platform == 'linux' and extra == 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.12' and sys_platform == 'linux' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.12' and sys_platform == 'linux' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version < '3.10' and sys_platform == 'win32' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version < '3.10' and sys_platform == 'win32' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version < '3.10' and sys_platform == 'win32' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.12' and sys_platform == 'win32' and extra == 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch') or (python_full_version >= '3.12' and sys_platform == 'win32' and extra == 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.12' and sys_platform == 'win32' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.12' and sys_platform == 'win32' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (sys_platform != 'linux' and sys_platform != 'win32' and extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (sys_platform != 'linux' and sys_platform != 'win32' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (sys_platform != 'linux' and sys_platform != 'win32' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (sys_platform != 'linux' and sys_platform != 'win32' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (sys_platform != 'linux' and sys_platform != 'win32' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (sys_platform != 'linux' and sys_platform != 'win32' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (sys_platform == 'linux' and extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (sys_platform == 'linux' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (sys_platform == 'linux' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (sys_platform == 'win32' and extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (sys_platform == 'win32' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (sys_platform == 'win32' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (sys_platform == 'linux' and extra != 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (sys_platform == 'win32' and extra != 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal')" }, + { name = "nvidia-cuda-runtime", marker = "(python_full_version >= '3.10' and python_full_version < '3.12' and sys_platform == 'linux' and extra == 'group-13-lightly-train-minimal-torch') or (python_full_version >= '3.10' and python_full_version < '3.12' and sys_platform == 'linux' and extra != 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.12' and sys_platform == 'linux' and extra == 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch') or (python_full_version >= '3.12' and sys_platform == 'linux' and extra == 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version < '3.10' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version < '3.10' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version < '3.10' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.12' and extra == 'extra-13-lightly-train-onnx' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.12' and extra == 'extra-13-lightly-train-onnx' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.12' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.12' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.12' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.12' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.12' and extra != 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.12' and extra != 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (sys_platform != 'linux' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (sys_platform != 'linux' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (sys_platform != 'linux' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (extra != 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal')" }, ] cufft = [ - { name = "nvidia-cufft", marker = "(python_full_version >= '3.10' and python_full_version < '3.12' and sys_platform == 'linux' and extra == 'group-13-lightly-train-minimal-torch') or (python_full_version >= '3.10' and python_full_version < '3.12' and sys_platform == 'linux' and extra != 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.10' and python_full_version < '3.12' and sys_platform == 'win32' and extra == 'group-13-lightly-train-minimal-torch') or (python_full_version >= '3.10' and python_full_version < '3.12' and sys_platform == 'win32' and extra != 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version < '3.10' and sys_platform == 'linux' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version < '3.10' and sys_platform == 'linux' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version < '3.10' and sys_platform == 'linux' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.12' and sys_platform == 'linux' and extra == 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch') or (python_full_version >= '3.12' and sys_platform == 'linux' and extra == 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.12' and sys_platform == 'linux' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.12' and sys_platform == 'linux' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version < '3.10' and sys_platform == 'win32' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version < '3.10' and sys_platform == 'win32' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version < '3.10' and sys_platform == 'win32' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.12' and sys_platform == 'win32' and extra == 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch') or (python_full_version >= '3.12' and sys_platform == 'win32' and extra == 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.12' and sys_platform == 'win32' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.12' and sys_platform == 'win32' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (sys_platform != 'linux' and sys_platform != 'win32' and extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (sys_platform != 'linux' and sys_platform != 'win32' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (sys_platform != 'linux' and sys_platform != 'win32' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (sys_platform != 'linux' and sys_platform != 'win32' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (sys_platform != 'linux' and sys_platform != 'win32' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (sys_platform != 'linux' and sys_platform != 'win32' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (sys_platform == 'linux' and extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (sys_platform == 'linux' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (sys_platform == 'linux' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (sys_platform == 'win32' and extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (sys_platform == 'win32' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (sys_platform == 'win32' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (sys_platform == 'linux' and extra != 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (sys_platform == 'win32' and extra != 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal')" }, + { name = "nvidia-cufft", marker = "(python_full_version >= '3.10' and python_full_version < '3.12' and sys_platform == 'linux' and extra == 'group-13-lightly-train-minimal-torch') or (python_full_version >= '3.10' and python_full_version < '3.12' and sys_platform == 'linux' and extra != 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.12' and sys_platform == 'linux' and extra == 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch') or (python_full_version >= '3.12' and sys_platform == 'linux' and extra == 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version < '3.10' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version < '3.10' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version < '3.10' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.12' and extra == 'extra-13-lightly-train-onnx' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.12' and extra == 'extra-13-lightly-train-onnx' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.12' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.12' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.12' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.12' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.12' and extra != 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.12' and extra != 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (sys_platform != 'linux' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (sys_platform != 'linux' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (sys_platform != 'linux' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (extra != 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal')" }, ] cufile = [ { name = "nvidia-cufile", marker = "(python_full_version >= '3.10' and python_full_version < '3.12' and sys_platform == 'linux' and extra == 'group-13-lightly-train-minimal-torch') or (python_full_version >= '3.10' and python_full_version < '3.12' and sys_platform == 'linux' and extra != 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.12' and sys_platform == 'linux' and extra == 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch') or (python_full_version >= '3.12' and sys_platform == 'linux' and extra == 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version < '3.10' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version < '3.10' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version < '3.10' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.12' and extra == 'extra-13-lightly-train-onnx' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.12' and extra == 'extra-13-lightly-train-onnx' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.12' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.12' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.12' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.12' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.12' and extra != 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.12' and extra != 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (sys_platform != 'linux' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (sys_platform != 'linux' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (sys_platform != 'linux' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (extra != 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal')" }, ] cupti = [ - { name = "nvidia-cuda-cupti", marker = "(python_full_version >= '3.10' and python_full_version < '3.12' and sys_platform == 'linux' and extra == 'group-13-lightly-train-minimal-torch') or (python_full_version >= '3.10' and python_full_version < '3.12' and sys_platform == 'linux' and extra != 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.10' and python_full_version < '3.12' and sys_platform == 'win32' and extra == 'group-13-lightly-train-minimal-torch') or (python_full_version >= '3.10' and python_full_version < '3.12' and sys_platform == 'win32' and extra != 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version < '3.10' and sys_platform == 'linux' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version < '3.10' and sys_platform == 'linux' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version < '3.10' and sys_platform == 'linux' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.12' and sys_platform == 'linux' and extra == 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch') or (python_full_version >= '3.12' and sys_platform == 'linux' and extra == 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.12' and sys_platform == 'linux' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.12' and sys_platform == 'linux' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version < '3.10' and sys_platform == 'win32' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version < '3.10' and sys_platform == 'win32' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version < '3.10' and sys_platform == 'win32' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.12' and sys_platform == 'win32' and extra == 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch') or (python_full_version >= '3.12' and sys_platform == 'win32' and extra == 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.12' and sys_platform == 'win32' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.12' and sys_platform == 'win32' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (sys_platform != 'linux' and sys_platform != 'win32' and extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (sys_platform != 'linux' and sys_platform != 'win32' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (sys_platform != 'linux' and sys_platform != 'win32' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (sys_platform != 'linux' and sys_platform != 'win32' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (sys_platform != 'linux' and sys_platform != 'win32' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (sys_platform != 'linux' and sys_platform != 'win32' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (sys_platform == 'linux' and extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (sys_platform == 'linux' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (sys_platform == 'linux' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (sys_platform == 'win32' and extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (sys_platform == 'win32' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (sys_platform == 'win32' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (sys_platform == 'linux' and extra != 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (sys_platform == 'win32' and extra != 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal')" }, + { name = "nvidia-cuda-cupti", marker = "(python_full_version >= '3.10' and python_full_version < '3.12' and sys_platform == 'linux' and extra == 'group-13-lightly-train-minimal-torch') or (python_full_version >= '3.10' and python_full_version < '3.12' and sys_platform == 'linux' and extra != 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.12' and sys_platform == 'linux' and extra == 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch') or (python_full_version >= '3.12' and sys_platform == 'linux' and extra == 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version < '3.10' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version < '3.10' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version < '3.10' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.12' and extra == 'extra-13-lightly-train-onnx' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.12' and extra == 'extra-13-lightly-train-onnx' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.12' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.12' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.12' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.12' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.12' and extra != 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.12' and extra != 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (sys_platform != 'linux' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (sys_platform != 'linux' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (sys_platform != 'linux' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (extra != 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal')" }, ] curand = [ - { name = "nvidia-curand", marker = "(python_full_version >= '3.10' and python_full_version < '3.12' and sys_platform == 'linux' and extra == 'group-13-lightly-train-minimal-torch') or (python_full_version >= '3.10' and python_full_version < '3.12' and sys_platform == 'linux' and extra != 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.10' and python_full_version < '3.12' and sys_platform == 'win32' and extra == 'group-13-lightly-train-minimal-torch') or (python_full_version >= '3.10' and python_full_version < '3.12' and sys_platform == 'win32' and extra != 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version < '3.10' and sys_platform == 'linux' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version < '3.10' and sys_platform == 'linux' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version < '3.10' and sys_platform == 'linux' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.12' and sys_platform == 'linux' and extra == 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch') or (python_full_version >= '3.12' and sys_platform == 'linux' and extra == 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.12' and sys_platform == 'linux' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.12' and sys_platform == 'linux' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version < '3.10' and sys_platform == 'win32' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version < '3.10' and sys_platform == 'win32' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version < '3.10' and sys_platform == 'win32' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.12' and sys_platform == 'win32' and extra == 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch') or (python_full_version >= '3.12' and sys_platform == 'win32' and extra == 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.12' and sys_platform == 'win32' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.12' and sys_platform == 'win32' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (sys_platform != 'linux' and sys_platform != 'win32' and extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (sys_platform != 'linux' and sys_platform != 'win32' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (sys_platform != 'linux' and sys_platform != 'win32' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (sys_platform != 'linux' and sys_platform != 'win32' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (sys_platform != 'linux' and sys_platform != 'win32' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (sys_platform != 'linux' and sys_platform != 'win32' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (sys_platform == 'linux' and extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (sys_platform == 'linux' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (sys_platform == 'linux' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (sys_platform == 'win32' and extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (sys_platform == 'win32' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (sys_platform == 'win32' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (sys_platform == 'linux' and extra != 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (sys_platform == 'win32' and extra != 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal')" }, + { name = "nvidia-curand", marker = "(python_full_version >= '3.10' and python_full_version < '3.12' and sys_platform == 'linux' and extra == 'group-13-lightly-train-minimal-torch') or (python_full_version >= '3.10' and python_full_version < '3.12' and sys_platform == 'linux' and extra != 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.12' and sys_platform == 'linux' and extra == 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch') or (python_full_version >= '3.12' and sys_platform == 'linux' and extra == 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version < '3.10' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version < '3.10' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version < '3.10' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.12' and extra == 'extra-13-lightly-train-onnx' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.12' and extra == 'extra-13-lightly-train-onnx' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.12' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.12' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.12' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.12' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.12' and extra != 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.12' and extra != 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (sys_platform != 'linux' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (sys_platform != 'linux' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (sys_platform != 'linux' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (extra != 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal')" }, ] cusolver = [ - { name = "nvidia-cusolver", marker = "(python_full_version >= '3.10' and python_full_version < '3.12' and sys_platform == 'linux' and extra == 'group-13-lightly-train-minimal-torch') or (python_full_version >= '3.10' and python_full_version < '3.12' and sys_platform == 'linux' and extra != 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.10' and python_full_version < '3.12' and sys_platform == 'win32' and extra == 'group-13-lightly-train-minimal-torch') or (python_full_version >= '3.10' and python_full_version < '3.12' and sys_platform == 'win32' and extra != 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version < '3.10' and sys_platform == 'linux' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version < '3.10' and sys_platform == 'linux' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version < '3.10' and sys_platform == 'linux' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.12' and sys_platform == 'linux' and extra == 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch') or (python_full_version >= '3.12' and sys_platform == 'linux' and extra == 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.12' and sys_platform == 'linux' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.12' and sys_platform == 'linux' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version < '3.10' and sys_platform == 'win32' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version < '3.10' and sys_platform == 'win32' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version < '3.10' and sys_platform == 'win32' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.12' and sys_platform == 'win32' and extra == 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch') or (python_full_version >= '3.12' and sys_platform == 'win32' and extra == 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.12' and sys_platform == 'win32' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.12' and sys_platform == 'win32' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (sys_platform != 'linux' and sys_platform != 'win32' and extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (sys_platform != 'linux' and sys_platform != 'win32' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (sys_platform != 'linux' and sys_platform != 'win32' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (sys_platform != 'linux' and sys_platform != 'win32' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (sys_platform != 'linux' and sys_platform != 'win32' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (sys_platform != 'linux' and sys_platform != 'win32' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (sys_platform == 'linux' and extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (sys_platform == 'linux' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (sys_platform == 'linux' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (sys_platform == 'win32' and extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (sys_platform == 'win32' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (sys_platform == 'win32' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (sys_platform == 'linux' and extra != 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (sys_platform == 'win32' and extra != 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal')" }, + { name = "nvidia-cusolver", marker = "(python_full_version >= '3.10' and python_full_version < '3.12' and sys_platform == 'linux' and extra == 'group-13-lightly-train-minimal-torch') or (python_full_version >= '3.10' and python_full_version < '3.12' and sys_platform == 'linux' and extra != 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.12' and sys_platform == 'linux' and extra == 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch') or (python_full_version >= '3.12' and sys_platform == 'linux' and extra == 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version < '3.10' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version < '3.10' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version < '3.10' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.12' and extra == 'extra-13-lightly-train-onnx' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.12' and extra == 'extra-13-lightly-train-onnx' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.12' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.12' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.12' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.12' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.12' and extra != 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.12' and extra != 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (sys_platform != 'linux' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (sys_platform != 'linux' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (sys_platform != 'linux' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (extra != 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal')" }, ] cusparse = [ - { name = "nvidia-cusparse", marker = "(python_full_version >= '3.10' and python_full_version < '3.12' and sys_platform == 'linux' and extra == 'group-13-lightly-train-minimal-torch') or (python_full_version >= '3.10' and python_full_version < '3.12' and sys_platform == 'linux' and extra != 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.10' and python_full_version < '3.12' and sys_platform == 'win32' and extra == 'group-13-lightly-train-minimal-torch') or (python_full_version >= '3.10' and python_full_version < '3.12' and sys_platform == 'win32' and extra != 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version < '3.10' and sys_platform == 'linux' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version < '3.10' and sys_platform == 'linux' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version < '3.10' and sys_platform == 'linux' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.12' and sys_platform == 'linux' and extra == 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch') or (python_full_version >= '3.12' and sys_platform == 'linux' and extra == 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.12' and sys_platform == 'linux' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.12' and sys_platform == 'linux' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version < '3.10' and sys_platform == 'win32' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version < '3.10' and sys_platform == 'win32' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version < '3.10' and sys_platform == 'win32' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.12' and sys_platform == 'win32' and extra == 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch') or (python_full_version >= '3.12' and sys_platform == 'win32' and extra == 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.12' and sys_platform == 'win32' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.12' and sys_platform == 'win32' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (sys_platform != 'linux' and sys_platform != 'win32' and extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (sys_platform != 'linux' and sys_platform != 'win32' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (sys_platform != 'linux' and sys_platform != 'win32' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (sys_platform != 'linux' and sys_platform != 'win32' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (sys_platform != 'linux' and sys_platform != 'win32' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (sys_platform != 'linux' and sys_platform != 'win32' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (sys_platform == 'linux' and extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (sys_platform == 'linux' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (sys_platform == 'linux' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (sys_platform == 'win32' and extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (sys_platform == 'win32' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (sys_platform == 'win32' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (sys_platform == 'linux' and extra != 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (sys_platform == 'win32' and extra != 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal')" }, + { name = "nvidia-cusparse", marker = "(python_full_version >= '3.10' and python_full_version < '3.12' and sys_platform == 'linux' and extra == 'group-13-lightly-train-minimal-torch') or (python_full_version >= '3.10' and python_full_version < '3.12' and sys_platform == 'linux' and extra != 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.12' and sys_platform == 'linux' and extra == 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch') or (python_full_version >= '3.12' and sys_platform == 'linux' and extra == 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version < '3.10' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version < '3.10' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version < '3.10' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.12' and extra == 'extra-13-lightly-train-onnx' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.12' and extra == 'extra-13-lightly-train-onnx' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.12' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.12' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.12' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.12' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.12' and extra != 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.12' and extra != 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (sys_platform != 'linux' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (sys_platform != 'linux' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (sys_platform != 'linux' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (extra != 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal')" }, ] nvjitlink = [ - { name = "nvidia-nvjitlink", marker = "(python_full_version >= '3.10' and python_full_version < '3.12' and sys_platform == 'linux' and extra == 'group-13-lightly-train-minimal-torch') or (python_full_version >= '3.10' and python_full_version < '3.12' and sys_platform == 'linux' and extra != 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.10' and python_full_version < '3.12' and sys_platform == 'win32' and extra == 'group-13-lightly-train-minimal-torch') or (python_full_version >= '3.10' and python_full_version < '3.12' and sys_platform == 'win32' and extra != 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version < '3.10' and sys_platform == 'linux' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version < '3.10' and sys_platform == 'linux' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version < '3.10' and sys_platform == 'linux' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.12' and sys_platform == 'linux' and extra == 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch') or (python_full_version >= '3.12' and sys_platform == 'linux' and extra == 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.12' and sys_platform == 'linux' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.12' and sys_platform == 'linux' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version < '3.10' and sys_platform == 'win32' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version < '3.10' and sys_platform == 'win32' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version < '3.10' and sys_platform == 'win32' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.12' and sys_platform == 'win32' and extra == 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch') or (python_full_version >= '3.12' and sys_platform == 'win32' and extra == 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.12' and sys_platform == 'win32' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.12' and sys_platform == 'win32' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (sys_platform != 'linux' and sys_platform != 'win32' and extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (sys_platform != 'linux' and sys_platform != 'win32' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (sys_platform != 'linux' and sys_platform != 'win32' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (sys_platform != 'linux' and sys_platform != 'win32' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (sys_platform != 'linux' and sys_platform != 'win32' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (sys_platform != 'linux' and sys_platform != 'win32' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (sys_platform == 'linux' and extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (sys_platform == 'linux' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (sys_platform == 'linux' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (sys_platform == 'win32' and extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (sys_platform == 'win32' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (sys_platform == 'win32' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (sys_platform == 'linux' and extra != 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (sys_platform == 'win32' and extra != 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal')" }, + { name = "nvidia-nvjitlink", marker = "(python_full_version >= '3.10' and python_full_version < '3.12' and sys_platform == 'linux' and extra == 'group-13-lightly-train-minimal-torch') or (python_full_version >= '3.10' and python_full_version < '3.12' and sys_platform == 'linux' and extra != 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.12' and sys_platform == 'linux' and extra == 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch') or (python_full_version >= '3.12' and sys_platform == 'linux' and extra == 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version < '3.10' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version < '3.10' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version < '3.10' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.12' and extra == 'extra-13-lightly-train-onnx' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.12' and extra == 'extra-13-lightly-train-onnx' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.12' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.12' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.12' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.12' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.12' and extra != 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.12' and extra != 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (sys_platform != 'linux' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (sys_platform != 'linux' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (sys_platform != 'linux' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (extra != 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal')" }, ] nvrtc = [ - { name = "nvidia-cuda-nvrtc", marker = "(python_full_version >= '3.10' and python_full_version < '3.12' and sys_platform == 'linux' and extra == 'group-13-lightly-train-minimal-torch') or (python_full_version >= '3.10' and python_full_version < '3.12' and sys_platform == 'linux' and extra != 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.10' and python_full_version < '3.12' and sys_platform == 'win32' and extra == 'group-13-lightly-train-minimal-torch') or (python_full_version >= '3.10' and python_full_version < '3.12' and sys_platform == 'win32' and extra != 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version < '3.10' and sys_platform == 'linux' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version < '3.10' and sys_platform == 'linux' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version < '3.10' and sys_platform == 'linux' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.12' and sys_platform == 'linux' and extra == 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch') or (python_full_version >= '3.12' and sys_platform == 'linux' and extra == 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.12' and sys_platform == 'linux' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.12' and sys_platform == 'linux' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version < '3.10' and sys_platform == 'win32' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version < '3.10' and sys_platform == 'win32' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version < '3.10' and sys_platform == 'win32' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.12' and sys_platform == 'win32' and extra == 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch') or (python_full_version >= '3.12' and sys_platform == 'win32' and extra == 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.12' and sys_platform == 'win32' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.12' and sys_platform == 'win32' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (sys_platform != 'linux' and sys_platform != 'win32' and extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (sys_platform != 'linux' and sys_platform != 'win32' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (sys_platform != 'linux' and sys_platform != 'win32' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (sys_platform != 'linux' and sys_platform != 'win32' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (sys_platform != 'linux' and sys_platform != 'win32' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (sys_platform != 'linux' and sys_platform != 'win32' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (sys_platform == 'linux' and extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (sys_platform == 'linux' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (sys_platform == 'linux' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (sys_platform == 'win32' and extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (sys_platform == 'win32' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (sys_platform == 'win32' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (sys_platform == 'linux' and extra != 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (sys_platform == 'win32' and extra != 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal')" }, + { name = "nvidia-cuda-nvrtc", marker = "(python_full_version >= '3.10' and python_full_version < '3.12' and sys_platform == 'linux' and extra == 'group-13-lightly-train-minimal-torch') or (python_full_version >= '3.10' and python_full_version < '3.12' and sys_platform == 'linux' and extra != 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.12' and sys_platform == 'linux' and extra == 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch') or (python_full_version >= '3.12' and sys_platform == 'linux' and extra == 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version < '3.10' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version < '3.10' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version < '3.10' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.12' and extra == 'extra-13-lightly-train-onnx' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.12' and extra == 'extra-13-lightly-train-onnx' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.12' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.12' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.12' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.12' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.12' and extra != 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.12' and extra != 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (sys_platform != 'linux' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (sys_platform != 'linux' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (sys_platform != 'linux' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (extra != 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal')" }, ] nvtx = [ - { name = "nvidia-nvtx", marker = "(python_full_version >= '3.10' and python_full_version < '3.12' and sys_platform == 'linux' and extra == 'group-13-lightly-train-minimal-torch') or (python_full_version >= '3.10' and python_full_version < '3.12' and sys_platform == 'linux' and extra != 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.10' and python_full_version < '3.12' and sys_platform == 'win32' and extra == 'group-13-lightly-train-minimal-torch') or (python_full_version >= '3.10' and python_full_version < '3.12' and sys_platform == 'win32' and extra != 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version < '3.10' and sys_platform == 'linux' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version < '3.10' and sys_platform == 'linux' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version < '3.10' and sys_platform == 'linux' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.12' and sys_platform == 'linux' and extra == 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch') or (python_full_version >= '3.12' and sys_platform == 'linux' and extra == 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.12' and sys_platform == 'linux' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.12' and sys_platform == 'linux' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version < '3.10' and sys_platform == 'win32' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version < '3.10' and sys_platform == 'win32' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version < '3.10' and sys_platform == 'win32' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.12' and sys_platform == 'win32' and extra == 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch') or (python_full_version >= '3.12' and sys_platform == 'win32' and extra == 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.12' and sys_platform == 'win32' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.12' and sys_platform == 'win32' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (sys_platform != 'linux' and sys_platform != 'win32' and extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (sys_platform != 'linux' and sys_platform != 'win32' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (sys_platform != 'linux' and sys_platform != 'win32' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (sys_platform != 'linux' and sys_platform != 'win32' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (sys_platform != 'linux' and sys_platform != 'win32' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (sys_platform != 'linux' and sys_platform != 'win32' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (sys_platform == 'linux' and extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (sys_platform == 'linux' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (sys_platform == 'linux' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (sys_platform == 'win32' and extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (sys_platform == 'win32' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (sys_platform == 'win32' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (sys_platform == 'linux' and extra != 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (sys_platform == 'win32' and extra != 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal')" }, + { name = "nvidia-nvtx", marker = "(python_full_version >= '3.10' and python_full_version < '3.12' and sys_platform == 'linux' and extra == 'group-13-lightly-train-minimal-torch') or (python_full_version >= '3.10' and python_full_version < '3.12' and sys_platform == 'linux' and extra != 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.12' and sys_platform == 'linux' and extra == 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch') or (python_full_version >= '3.12' and sys_platform == 'linux' and extra == 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version < '3.10' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version < '3.10' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version < '3.10' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.12' and extra == 'extra-13-lightly-train-onnx' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.12' and extra == 'extra-13-lightly-train-onnx' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.12' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.12' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.12' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.12' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.12' and extra != 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.12' and extra != 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (sys_platform != 'linux' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (sys_platform != 'linux' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (sys_platform != 'linux' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (extra != 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal')" }, ] [[package]] @@ -14696,7 +14693,7 @@ resolution-markers = [ ] dependencies = [ { name = "packaging", version = "24.2", source = { registry = "https://pypi.org/simple" }, marker = "(python_full_version < '3.9' and sys_platform != 'win32') or (python_full_version >= '3.9' and extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version >= '3.9' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version >= '3.9' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version >= '3.9' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.9' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.9' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (sys_platform == 'win32' and extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (sys_platform == 'win32' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (sys_platform == 'win32' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (sys_platform == 'win32' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (sys_platform == 'win32' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (sys_platform == 'win32' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal')" }, - { name = "packaging", version = "25.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version == '3.9.*' or (extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal')" }, + { name = "packaging", version = "25.0", source = { registry = "https://pypi.org/simple" }, marker = "(python_full_version == '3.9.*' and sys_platform != 'win32') or (python_full_version != '3.9.*' and extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version != '3.9.*' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version != '3.9.*' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version != '3.9.*' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version != '3.9.*' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version != '3.9.*' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (sys_platform == 'win32' and extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (sys_platform == 'win32' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (sys_platform == 'win32' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (sys_platform == 'win32' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (sys_platform == 'win32' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (sys_platform == 'win32' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal')" }, ] sdist = { url = "https://files.pythonhosted.org/packages/34/72/9614c465dc206155d93eff0ca20d42e1e35afc533971379482de953521a4/gunicorn-23.0.0.tar.gz", hash = "sha256:f014447a0101dc57e294f6c18ca6b40227a4c90e9bdb586042628030cba004ec", size = 375031, upload-time = "2024-08-10T20:25:27.378Z" } wheels = [ @@ -14908,7 +14905,7 @@ resolution-markers = [ "python_full_version == '3.10.*' and sys_platform != 'darwin' and sys_platform != 'linux' and sys_platform != 'win32' and extra != 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-minimal-torch' and extra != 'group-13-lightly-train-pinned-torch-maximal' and extra != 'group-13-lightly-train-pinned-torch-minimal'", ] dependencies = [ - { name = "packaging", version = "26.2", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.10' or (extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal')" }, + { name = "packaging", version = "26.2", source = { registry = "https://pypi.org/simple" }, marker = "(python_full_version >= '3.10' and sys_platform != 'win32') or (python_full_version < '3.10' and extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version < '3.10' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version < '3.10' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version < '3.10' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version < '3.10' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version < '3.10' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (sys_platform == 'win32' and extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (sys_platform == 'win32' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (sys_platform == 'win32' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (sys_platform == 'win32' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (sys_platform == 'win32' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (sys_platform == 'win32' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal')" }, ] sdist = { url = "https://files.pythonhosted.org/packages/c4/f4/e78fa054248fab913e2eab0332c6c2cb07421fca1ce56d8fe43b6aef57a4/gunicorn-25.3.0.tar.gz", hash = "sha256:f74e1b2f9f76f6cd1ca01198968bd2dd65830edc24b6e8e4d78de8320e2fe889", size = 634883, upload-time = "2026-03-27T00:00:26.092Z" } wheels = [ @@ -18167,7 +18164,7 @@ source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "more-itertools", version = "10.5.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.9' or (extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal')" }, { name = "more-itertools", version = "10.8.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version == '3.9.*' or (extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal')" }, - { name = "more-itertools", version = "11.0.2", source = { registry = "https://pypi.org/simple" }, marker = "(python_full_version >= '3.10' and python_full_version < '3.12') or (python_full_version >= '3.10' and platform_machine != 's390x') or (python_full_version >= '3.12' and platform_machine == 's390x' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version >= '3.12' and platform_machine == 's390x' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.12' and platform_machine == 's390x' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.12' and platform_machine == 's390x' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version < '3.10' and extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version < '3.10' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version < '3.10' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version < '3.10' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version < '3.10' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version < '3.10' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal')" }, + { name = "more-itertools", version = "11.0.2", source = { registry = "https://pypi.org/simple" }, marker = "(python_full_version >= '3.10' and python_full_version < '3.12' and extra == 'extra-13-lightly-train-onnx') or (python_full_version >= '3.10' and python_full_version < '3.12' and extra == 'extra-13-lightly-train-onnxruntime') or (python_full_version >= '3.10' and python_full_version < '3.12' and extra == 'extra-13-lightly-train-rfdetr') or (python_full_version >= '3.10' and python_full_version < '3.12' and extra != 'extra-13-lightly-train-super-gradients') or (python_full_version >= '3.10' and python_full_version < '3.12' and extra == 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch') or (python_full_version >= '3.10' and python_full_version < '3.12' and extra == 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.10' and python_full_version < '3.12' and extra == 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.10' and platform_machine != 's390x') or (python_full_version >= '3.12' and platform_machine == 's390x' and extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version >= '3.12' and platform_machine == 's390x' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version >= '3.12' and platform_machine == 's390x' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version >= '3.12' and platform_machine == 's390x' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.12' and platform_machine == 's390x' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.12' and platform_machine == 's390x' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version < '3.10' and extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version < '3.10' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version < '3.10' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version < '3.10' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version < '3.10' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version < '3.10' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal')" }, ] sdist = { url = "https://files.pythonhosted.org/packages/06/c0/ed4a27bc5571b99e3cff68f8a9fa5b56ff7df1c2251cc715a652ddd26402/jaraco.classes-3.4.0.tar.gz", hash = "sha256:47a024b51d0239c0dd8c8540c6c7f484be3b8fcf0b2d85c13825780d3b3f3acd", size = 11780, upload-time = "2024-03-31T07:27:36.643Z" } wheels = [ @@ -18417,7 +18414,7 @@ resolution-markers = [ "python_full_version == '3.10.*' and sys_platform != 'darwin' and sys_platform != 'linux' and sys_platform != 'win32' and extra != 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-minimal-torch' and extra != 'group-13-lightly-train-pinned-torch-maximal' and extra != 'group-13-lightly-train-pinned-torch-minimal'", ] dependencies = [ - { name = "backports-tarfile", marker = "(python_full_version >= '3.10' and python_full_version < '3.12') or (python_full_version < '3.10' and extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version < '3.10' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version < '3.10' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version < '3.10' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version < '3.10' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version < '3.10' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.12' and extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version >= '3.12' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version >= '3.12' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version >= '3.12' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.12' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.12' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal')" }, + { name = "backports-tarfile", marker = "(python_full_version >= '3.10' and python_full_version < '3.12' and platform_machine != 's390x') or (python_full_version >= '3.10' and python_full_version < '3.12' and extra == 'extra-13-lightly-train-onnx') or (python_full_version >= '3.10' and python_full_version < '3.12' and extra == 'extra-13-lightly-train-onnxruntime') or (python_full_version >= '3.10' and python_full_version < '3.12' and extra == 'extra-13-lightly-train-rfdetr') or (python_full_version >= '3.10' and python_full_version < '3.12' and extra != 'extra-13-lightly-train-super-gradients') or (python_full_version >= '3.10' and python_full_version < '3.12' and extra == 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch') or (python_full_version >= '3.10' and python_full_version < '3.12' and extra == 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.10' and python_full_version < '3.12' and extra == 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version < '3.10' and extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version < '3.10' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version < '3.10' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version < '3.10' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version < '3.10' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version < '3.10' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.12' and extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version >= '3.12' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version >= '3.12' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version >= '3.12' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.12' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.12' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal')" }, ] sdist = { url = "https://files.pythonhosted.org/packages/af/50/4763cd07e722bb6285316d390a164bc7e479db9d90daa769f22578f698b4/jaraco_context-6.1.2.tar.gz", hash = "sha256:f1a6c9d391e661cc5b8d39861ff077a7dc24dc23833ccee564b234b81c82dfe3", size = 16801, upload-time = "2026-03-20T22:13:33.922Z" } wheels = [ @@ -18667,7 +18664,7 @@ resolution-markers = [ "python_full_version == '3.10.*' and sys_platform != 'darwin' and sys_platform != 'linux' and sys_platform != 'win32' and extra != 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-minimal-torch' and extra != 'group-13-lightly-train-pinned-torch-maximal' and extra != 'group-13-lightly-train-pinned-torch-minimal'", ] dependencies = [ - { name = "more-itertools", version = "11.0.2", source = { registry = "https://pypi.org/simple" }, marker = "(python_full_version >= '3.10' and python_full_version < '3.12') or (python_full_version >= '3.10' and platform_machine != 's390x') or (python_full_version >= '3.12' and platform_machine == 's390x' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version >= '3.12' and platform_machine == 's390x' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.12' and platform_machine == 's390x' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.12' and platform_machine == 's390x' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version < '3.10' and extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version < '3.10' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version < '3.10' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version < '3.10' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version < '3.10' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version < '3.10' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal')" }, + { name = "more-itertools", version = "11.0.2", source = { registry = "https://pypi.org/simple" }, marker = "(python_full_version >= '3.10' and python_full_version < '3.12' and extra == 'extra-13-lightly-train-onnx') or (python_full_version >= '3.10' and python_full_version < '3.12' and extra == 'extra-13-lightly-train-onnxruntime') or (python_full_version >= '3.10' and python_full_version < '3.12' and extra == 'extra-13-lightly-train-rfdetr') or (python_full_version >= '3.10' and python_full_version < '3.12' and extra != 'extra-13-lightly-train-super-gradients') or (python_full_version >= '3.10' and python_full_version < '3.12' and extra == 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch') or (python_full_version >= '3.10' and python_full_version < '3.12' and extra == 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.10' and python_full_version < '3.12' and extra == 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.10' and platform_machine != 's390x') or (python_full_version >= '3.12' and platform_machine == 's390x' and extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version >= '3.12' and platform_machine == 's390x' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version >= '3.12' and platform_machine == 's390x' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version >= '3.12' and platform_machine == 's390x' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.12' and platform_machine == 's390x' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.12' and platform_machine == 's390x' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version < '3.10' and extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version < '3.10' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version < '3.10' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version < '3.10' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version < '3.10' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version < '3.10' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal')" }, ] sdist = { url = "https://files.pythonhosted.org/packages/36/cf/ea4ef2920830dea3f5ab2ea4da6fb67724e6dca80ee2553788c3607243d0/jaraco_functools-4.5.0.tar.gz", hash = "sha256:3bb5665ea4a020cf78a7040e89154c77edadb3ca74f366479669c5999aa70b03", size = 20272, upload-time = "2026-05-15T21:34:10.025Z" } wheels = [ @@ -22680,16 +22677,16 @@ resolution-markers = [ "(python_full_version == '3.9.*' and platform_machine != 'arm64' and sys_platform == 'darwin' and extra != 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-minimal-torch' and extra != 'group-13-lightly-train-pinned-torch-maximal' and extra != 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version == '3.9.*' and sys_platform != 'darwin' and sys_platform != 'linux' and sys_platform != 'win32' and extra != 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-minimal-torch' and extra != 'group-13-lightly-train-pinned-torch-maximal' and extra != 'group-13-lightly-train-pinned-torch-minimal')", ] dependencies = [ - { name = "importlib-metadata", version = "8.7.1", source = { registry = "https://pypi.org/simple" }, marker = "(python_full_version >= '3.9' and python_full_version < '3.12') or (python_full_version < '3.9' and extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version < '3.9' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version < '3.9' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version < '3.9' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version < '3.9' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version < '3.9' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.12' and extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version >= '3.12' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version >= '3.12' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version >= '3.12' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.12' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.12' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal')" }, - { name = "jaraco-classes", marker = "(python_full_version >= '3.9' and python_full_version < '3.12') or (python_full_version >= '3.9' and platform_machine != 's390x') or (python_full_version >= '3.12' and platform_machine == 's390x' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version >= '3.12' and platform_machine == 's390x' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.12' and platform_machine == 's390x' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.12' and platform_machine == 's390x' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version < '3.9' and extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version < '3.9' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version < '3.9' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version < '3.9' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version < '3.9' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version < '3.9' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal')" }, + { name = "importlib-metadata", version = "8.7.1", source = { registry = "https://pypi.org/simple" }, marker = "(python_full_version >= '3.9' and python_full_version < '3.12' and platform_machine != 's390x') or (python_full_version >= '3.10' and python_full_version < '3.12' and platform_machine == 's390x' and extra == 'extra-13-lightly-train-onnx') or (python_full_version >= '3.10' and python_full_version < '3.12' and platform_machine == 's390x' and extra == 'extra-13-lightly-train-onnxruntime') or (python_full_version >= '3.10' and python_full_version < '3.12' and platform_machine == 's390x' and extra == 'extra-13-lightly-train-rfdetr') or (python_full_version >= '3.10' and python_full_version < '3.12' and platform_machine == 's390x' and extra != 'extra-13-lightly-train-super-gradients') or (python_full_version >= '3.10' and python_full_version < '3.12' and platform_machine == 's390x' and extra == 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch') or (python_full_version >= '3.10' and python_full_version < '3.12' and platform_machine == 's390x' and extra == 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.10' and python_full_version < '3.12' and platform_machine == 's390x' and extra == 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version == '3.9.*' and platform_machine == 's390x') or (python_full_version < '3.9' and extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version < '3.9' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version < '3.9' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version < '3.9' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version < '3.9' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version < '3.9' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.12' and extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version >= '3.12' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version >= '3.12' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version >= '3.12' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.12' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.12' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal')" }, + { name = "jaraco-classes", marker = "(python_full_version >= '3.10' and python_full_version < '3.12' and platform_machine == 's390x' and extra == 'extra-13-lightly-train-onnx') or (python_full_version >= '3.10' and python_full_version < '3.12' and platform_machine == 's390x' and extra == 'extra-13-lightly-train-onnxruntime') or (python_full_version >= '3.10' and python_full_version < '3.12' and platform_machine == 's390x' and extra == 'extra-13-lightly-train-rfdetr') or (python_full_version >= '3.10' and python_full_version < '3.12' and platform_machine == 's390x' and extra != 'extra-13-lightly-train-super-gradients') or (python_full_version >= '3.10' and python_full_version < '3.12' and platform_machine == 's390x' and extra == 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch') or (python_full_version >= '3.10' and python_full_version < '3.12' and platform_machine == 's390x' and extra == 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.10' and python_full_version < '3.12' and platform_machine == 's390x' and extra == 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.9' and platform_machine != 's390x') or (python_full_version == '3.9.*' and platform_machine == 's390x') or (python_full_version >= '3.12' and platform_machine == 's390x' and extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version >= '3.12' and platform_machine == 's390x' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version >= '3.12' and platform_machine == 's390x' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version >= '3.12' and platform_machine == 's390x' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.12' and platform_machine == 's390x' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.12' and platform_machine == 's390x' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version < '3.9' and extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version < '3.9' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version < '3.9' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version < '3.9' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version < '3.9' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version < '3.9' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal')" }, { name = "jaraco-context", version = "6.1.1", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version == '3.9.*' or (extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal')" }, - { name = "jaraco-context", version = "6.1.2", source = { registry = "https://pypi.org/simple" }, marker = "(python_full_version >= '3.10' and python_full_version < '3.12') or (python_full_version >= '3.10' and platform_machine != 's390x') or (python_full_version >= '3.12' and platform_machine == 's390x' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version >= '3.12' and platform_machine == 's390x' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.12' and platform_machine == 's390x' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.12' and platform_machine == 's390x' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version < '3.10' and extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version < '3.10' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version < '3.10' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version < '3.10' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version < '3.10' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version < '3.10' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal')" }, + { name = "jaraco-context", version = "6.1.2", source = { registry = "https://pypi.org/simple" }, marker = "(python_full_version >= '3.10' and python_full_version < '3.12' and extra == 'extra-13-lightly-train-onnx') or (python_full_version >= '3.10' and python_full_version < '3.12' and extra == 'extra-13-lightly-train-onnxruntime') or (python_full_version >= '3.10' and python_full_version < '3.12' and extra == 'extra-13-lightly-train-rfdetr') or (python_full_version >= '3.10' and python_full_version < '3.12' and extra != 'extra-13-lightly-train-super-gradients') or (python_full_version >= '3.10' and python_full_version < '3.12' and extra == 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch') or (python_full_version >= '3.10' and python_full_version < '3.12' and extra == 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.10' and python_full_version < '3.12' and extra == 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.10' and platform_machine != 's390x') or (python_full_version >= '3.12' and platform_machine == 's390x' and extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version >= '3.12' and platform_machine == 's390x' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version >= '3.12' and platform_machine == 's390x' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version >= '3.12' and platform_machine == 's390x' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.12' and platform_machine == 's390x' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.12' and platform_machine == 's390x' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version < '3.10' and extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version < '3.10' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version < '3.10' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version < '3.10' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version < '3.10' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version < '3.10' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal')" }, { name = "jaraco-functools", version = "4.4.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version == '3.9.*' or (extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal')" }, - { name = "jaraco-functools", version = "4.5.0", source = { registry = "https://pypi.org/simple" }, marker = "(python_full_version >= '3.10' and python_full_version < '3.12') or (python_full_version >= '3.10' and platform_machine != 's390x') or (python_full_version >= '3.12' and platform_machine == 's390x' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version >= '3.12' and platform_machine == 's390x' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.12' and platform_machine == 's390x' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.12' and platform_machine == 's390x' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version < '3.10' and extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version < '3.10' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version < '3.10' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version < '3.10' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version < '3.10' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version < '3.10' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal')" }, - { name = "jeepney", marker = "(python_full_version >= '3.9' and python_full_version < '3.12' and sys_platform == 'linux') or (python_full_version >= '3.9' and platform_machine != 's390x' and sys_platform == 'linux') or (python_full_version >= '3.12' and platform_machine == 's390x' and sys_platform == 'linux' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version >= '3.12' and platform_machine == 's390x' and extra != 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.12' and platform_machine == 's390x' and extra != 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.12' and platform_machine == 's390x' and extra != 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version < '3.9' and extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version < '3.9' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version < '3.9' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version < '3.9' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version < '3.9' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version < '3.9' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (sys_platform != 'linux' and extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (sys_platform != 'linux' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (sys_platform != 'linux' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (sys_platform != 'linux' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (sys_platform != 'linux' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (sys_platform != 'linux' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal')" }, - { name = "pywin32-ctypes", marker = "(python_full_version >= '3.9' and python_full_version < '3.12' and sys_platform == 'win32') or (python_full_version >= '3.9' and platform_machine != 's390x' and sys_platform == 'win32') or (python_full_version >= '3.12' and platform_machine == 's390x' and sys_platform == 'win32' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version >= '3.12' and platform_machine == 's390x' and extra != 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.12' and platform_machine == 's390x' and extra != 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.12' and platform_machine == 's390x' and extra != 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version < '3.9' and extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version < '3.9' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version < '3.9' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version < '3.9' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version < '3.9' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version < '3.9' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (sys_platform != 'win32' and extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (sys_platform != 'win32' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (sys_platform != 'win32' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (sys_platform != 'win32' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (sys_platform != 'win32' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (sys_platform != 'win32' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal')" }, + { name = "jaraco-functools", version = "4.5.0", source = { registry = "https://pypi.org/simple" }, marker = "(python_full_version >= '3.10' and python_full_version < '3.12' and extra == 'extra-13-lightly-train-onnx') or (python_full_version >= '3.10' and python_full_version < '3.12' and extra == 'extra-13-lightly-train-onnxruntime') or (python_full_version >= '3.10' and python_full_version < '3.12' and extra == 'extra-13-lightly-train-rfdetr') or (python_full_version >= '3.10' and python_full_version < '3.12' and extra != 'extra-13-lightly-train-super-gradients') or (python_full_version >= '3.10' and python_full_version < '3.12' and extra == 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch') or (python_full_version >= '3.10' and python_full_version < '3.12' and extra == 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.10' and python_full_version < '3.12' and extra == 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.10' and platform_machine != 's390x') or (python_full_version >= '3.12' and platform_machine == 's390x' and extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version >= '3.12' and platform_machine == 's390x' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version >= '3.12' and platform_machine == 's390x' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version >= '3.12' and platform_machine == 's390x' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.12' and platform_machine == 's390x' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.12' and platform_machine == 's390x' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version < '3.10' and extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version < '3.10' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version < '3.10' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version < '3.10' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version < '3.10' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version < '3.10' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal')" }, + { name = "jeepney", marker = "(python_full_version >= '3.10' and python_full_version < '3.12' and platform_machine == 's390x' and sys_platform == 'linux' and extra == 'extra-13-lightly-train-onnx') or (python_full_version >= '3.10' and python_full_version < '3.12' and platform_machine == 's390x' and sys_platform == 'linux' and extra == 'extra-13-lightly-train-onnxruntime') or (python_full_version >= '3.10' and python_full_version < '3.12' and platform_machine == 's390x' and sys_platform == 'linux' and extra == 'extra-13-lightly-train-rfdetr') or (python_full_version >= '3.10' and python_full_version < '3.12' and platform_machine == 's390x' and sys_platform == 'linux' and extra != 'extra-13-lightly-train-super-gradients') or (python_full_version >= '3.10' and python_full_version < '3.12' and platform_machine == 's390x' and sys_platform == 'linux' and extra == 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch') or (python_full_version >= '3.10' and python_full_version < '3.12' and platform_machine == 's390x' and sys_platform == 'linux' and extra == 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.10' and python_full_version < '3.12' and platform_machine == 's390x' and sys_platform == 'linux' and extra == 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.9' and platform_machine != 's390x' and sys_platform == 'linux') or (python_full_version == '3.9.*' and platform_machine == 's390x' and sys_platform == 'linux') or (python_full_version >= '3.12' and platform_machine == 's390x' and extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version >= '3.12' and platform_machine == 's390x' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version >= '3.12' and platform_machine == 's390x' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version >= '3.12' and platform_machine == 's390x' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.12' and platform_machine == 's390x' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.12' and platform_machine == 's390x' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version < '3.9' and extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version < '3.9' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version < '3.9' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version < '3.9' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version < '3.9' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version < '3.9' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (sys_platform != 'linux' and extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (sys_platform != 'linux' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (sys_platform != 'linux' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (sys_platform != 'linux' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (sys_platform != 'linux' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (sys_platform != 'linux' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal')" }, + { name = "pywin32-ctypes", marker = "(python_full_version >= '3.10' and python_full_version < '3.12' and platform_machine == 's390x' and sys_platform == 'win32' and extra == 'extra-13-lightly-train-onnx') or (python_full_version >= '3.10' and python_full_version < '3.12' and platform_machine == 's390x' and sys_platform == 'win32' and extra == 'extra-13-lightly-train-onnxruntime') or (python_full_version >= '3.10' and python_full_version < '3.12' and platform_machine == 's390x' and sys_platform == 'win32' and extra == 'extra-13-lightly-train-rfdetr') or (python_full_version >= '3.10' and python_full_version < '3.12' and platform_machine == 's390x' and sys_platform == 'win32' and extra != 'extra-13-lightly-train-super-gradients') or (python_full_version >= '3.10' and python_full_version < '3.12' and platform_machine == 's390x' and sys_platform == 'win32' and extra == 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch') or (python_full_version >= '3.10' and python_full_version < '3.12' and platform_machine == 's390x' and sys_platform == 'win32' and extra == 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.10' and python_full_version < '3.12' and platform_machine == 's390x' and sys_platform == 'win32' and extra == 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.9' and platform_machine != 's390x' and sys_platform == 'win32') or (python_full_version == '3.9.*' and platform_machine == 's390x' and sys_platform == 'win32') or (python_full_version >= '3.12' and platform_machine == 's390x' and extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version >= '3.12' and platform_machine == 's390x' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version >= '3.12' and platform_machine == 's390x' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version >= '3.12' and platform_machine == 's390x' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.12' and platform_machine == 's390x' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.12' and platform_machine == 's390x' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version < '3.9' and extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version < '3.9' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version < '3.9' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version < '3.9' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version < '3.9' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version < '3.9' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (sys_platform != 'win32' and extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (sys_platform != 'win32' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (sys_platform != 'win32' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (sys_platform != 'win32' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (sys_platform != 'win32' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (sys_platform != 'win32' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal')" }, { name = "secretstorage", version = "3.3.3", source = { registry = "https://pypi.org/simple" }, marker = "(python_full_version == '3.9.*' and sys_platform == 'linux') or (python_full_version != '3.9.*' and extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version != '3.9.*' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version != '3.9.*' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version != '3.9.*' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version != '3.9.*' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version != '3.9.*' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (sys_platform != 'linux' and extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (sys_platform != 'linux' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (sys_platform != 'linux' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (sys_platform != 'linux' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (sys_platform != 'linux' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (sys_platform != 'linux' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal')" }, - { name = "secretstorage", version = "3.5.0", source = { registry = "https://pypi.org/simple" }, marker = "(python_full_version >= '3.10' and python_full_version < '3.12' and sys_platform == 'linux') or (python_full_version >= '3.10' and platform_machine != 's390x' and sys_platform == 'linux') or (python_full_version >= '3.12' and platform_machine == 's390x' and sys_platform == 'linux' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version >= '3.12' and platform_machine == 's390x' and extra != 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.12' and platform_machine == 's390x' and extra != 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.12' and platform_machine == 's390x' and extra != 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version < '3.10' and extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version < '3.10' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version < '3.10' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version < '3.10' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version < '3.10' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version < '3.10' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (sys_platform != 'linux' and extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (sys_platform != 'linux' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (sys_platform != 'linux' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (sys_platform != 'linux' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (sys_platform != 'linux' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (sys_platform != 'linux' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal')" }, + { name = "secretstorage", version = "3.5.0", source = { registry = "https://pypi.org/simple" }, marker = "(python_full_version >= '3.10' and python_full_version < '3.12' and sys_platform == 'linux' and extra == 'extra-13-lightly-train-onnx') or (python_full_version >= '3.10' and python_full_version < '3.12' and sys_platform == 'linux' and extra == 'extra-13-lightly-train-onnxruntime') or (python_full_version >= '3.10' and python_full_version < '3.12' and sys_platform == 'linux' and extra == 'extra-13-lightly-train-rfdetr') or (python_full_version >= '3.10' and python_full_version < '3.12' and sys_platform == 'linux' and extra != 'extra-13-lightly-train-super-gradients') or (python_full_version >= '3.10' and python_full_version < '3.12' and sys_platform == 'linux' and extra == 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch') or (python_full_version >= '3.10' and python_full_version < '3.12' and sys_platform == 'linux' and extra == 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.10' and python_full_version < '3.12' and sys_platform == 'linux' and extra == 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.10' and platform_machine != 's390x' and sys_platform == 'linux') or (python_full_version >= '3.12' and platform_machine == 's390x' and extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version >= '3.12' and platform_machine == 's390x' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version >= '3.12' and platform_machine == 's390x' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version >= '3.12' and platform_machine == 's390x' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.12' and platform_machine == 's390x' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.12' and platform_machine == 's390x' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version < '3.10' and extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version < '3.10' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version < '3.10' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version < '3.10' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version < '3.10' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version < '3.10' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (sys_platform != 'linux' and extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (sys_platform != 'linux' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (sys_platform != 'linux' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (sys_platform != 'linux' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (sys_platform != 'linux' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (sys_platform != 'linux' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal')" }, ] sdist = { url = "https://files.pythonhosted.org/packages/43/4b/674af6ef2f97d56f0ab5153bf0bfa28ccb6c3ed4d1babf4305449668807b/keyring-25.7.0.tar.gz", hash = "sha256:fe01bd85eb3f8fb3dd0405defdeac9a5b4f6f0439edbb3149577f244a2e8245b", size = 63516, upload-time = "2025-11-16T16:26:09.482Z" } wheels = [ @@ -23740,7 +23737,7 @@ requires-dist = [ { name = "fsspec", specifier = ">=2023.1.0" }, { name = "lightly", specifier = ">=1.5.20" }, { name = "matplotlib", specifier = ">=3.5" }, - { name = "mlflow", marker = "extra == 'mlflow'", specifier = ">=2.0.0" }, + { name = "mlflow", marker = "extra == 'mlflow'", specifier = ">=2.8.0" }, { name = "notebook", marker = "extra == 'notebook'", specifier = ">=7.2.3" }, { name = "numpy", marker = "python_full_version >= '3.12'", specifier = ">1.23.0" }, { name = "nvidia-ml-py", specifier = ">=12" }, @@ -24178,6 +24175,7 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/24/52/d2a0cfeccb9bcdc47c7ee05cdae5d69b48c9acf20997790a6338bb0d0b3b/lxml-6.1.1-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:37a58976370f36d9329d118ad0b953c5aeb9119ac9c6a4e258942a225d0573a1", size = 5309825, upload-time = "2026-05-18T19:17:13.831Z" }, { url = "https://files.pythonhosted.org/packages/19/4a/b30944266776c2f49749ef2445aa7e78898194134b80ad776386f61b56ae/lxml-6.1.1-cp310-cp310-win32.whl", hash = "sha256:cea3f4c1af79af13cdb2da0c028111d8f8522d4f22a000c82385535f24e5cf3a", size = 3598402, upload-time = "2026-05-18T19:17:08.21Z" }, { url = "https://files.pythonhosted.org/packages/9e/97/33691c66a4d7ec1a5a98e7c909a5b83ee45c7f7ba4cf92b1c4cf26e98079/lxml-6.1.1-cp310-cp310-win_amd64.whl", hash = "sha256:3abf332af33a74288675d936fe861fd4344da0dd6622193fbc4f2bfbb35536b5", size = 4021295, upload-time = "2026-05-18T19:17:28.638Z" }, + { url = "https://files.pythonhosted.org/packages/d0/5f/26a4dd0e12b9456ff7b12a21af5b491eb6629680d1edd73f4140fd386bcf/lxml-6.1.1-cp310-cp310-win_arm64.whl", hash = "sha256:8dadbe5b217ff35b6a8d16610dd710219b59b76d13f0e3f0d9f36786206e4485", size = 3667717, upload-time = "2026-05-19T19:22:44.474Z" }, { url = "https://files.pythonhosted.org/packages/62/b0/83f481780d1548750b8ce2ec824073deef2f452d9cd1a6faff8507e3d16d/lxml-6.1.1-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:53b7d2b7a10b1c35c0a5e21e9224accf60c1bbfba523990732e521b2b73adef2", size = 8526461, upload-time = "2026-05-18T19:17:25.862Z" }, { url = "https://files.pythonhosted.org/packages/b9/d5/30fa0f808002c7329397bfbb24e306789c0b29f04aa5842c07b174b4216f/lxml-6.1.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:ff3f333630ab480244a1bff72043e511a91eb22e7595dead8653ee5612dd8f3d", size = 4595375, upload-time = "2026-05-18T19:17:34.555Z" }, { url = "https://files.pythonhosted.org/packages/4f/d2/edb71cf0e561581a7c5eb2626244320eb04e9f8ce6d563184fd668b45073/lxml-6.1.1-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:a4bbea04c97f6d78a48e3fbc1cb9116d2780b1b39e03a23f6eb9b603fd61f510", size = 4923654, upload-time = "2026-05-18T19:17:42.917Z" }, @@ -24193,6 +24191,7 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/64/5d/1d66b84f850089254c230ef6ea6b267a5a54e2e179a5d960036a05d501d7/lxml-6.1.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:80c2dfadb855da477cf73373ad29a333535dedb9b12bad02c9814c8e2b43bf08", size = 5226877, upload-time = "2026-05-18T19:18:00.875Z" }, { url = "https://files.pythonhosted.org/packages/ad/00/84c4b5302d42a2d0184f38d538c8a197f33b52a50bd4f7bcfe990bce3036/lxml-6.1.1-cp311-cp311-win32.whl", hash = "sha256:30a89d3ac8faec007453fb541f3f46807eeec88edd5826f6e3fe001752a2c621", size = 3594072, upload-time = "2026-05-18T19:17:12.714Z" }, { url = "https://files.pythonhosted.org/packages/61/9d/2e2f7d876349f45e0f3e29f72da311668853d59b58d473a2dea4f0160135/lxml-6.1.1-cp311-cp311-win_amd64.whl", hash = "sha256:abbefa31eee84842140f67acef1c828e28bba8bbf0c3bc6e5492a9af88152c28", size = 4025469, upload-time = "2026-05-18T19:17:50.566Z" }, + { url = "https://files.pythonhosted.org/packages/b0/d5/570e6390e4110331e6208b2ba83d1482cc9146808ee118b22824a34c1070/lxml-6.1.1-cp311-cp311-win_arm64.whl", hash = "sha256:dcb292aa7fe485ceff7af4f92e46c5af397daec5dff64871a528f0fc47a3cc5b", size = 3667640, upload-time = "2026-05-19T19:22:48.293Z" }, { url = "https://files.pythonhosted.org/packages/6a/6e/c4add832b6fc1e887125b96f880d7b9b70aae5248718e046b1704bcac4b9/lxml-6.1.1-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:104c09bda8d2a562824c0e319d0768ce26a779b7601e0931d33b09b53c392ef7", size = 8570821, upload-time = "2026-05-18T19:17:42.068Z" }, { url = "https://files.pythonhosted.org/packages/22/00/ff3009c88e65de8011630acf8ab5a09cb2becd2aaf47fba2f3449f6224e9/lxml-6.1.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:25c6997a9a534e016695a0ba06b2f07945de682731ff01065b6d5a4474179da1", size = 4624252, upload-time = "2026-05-18T19:17:47.897Z" }, { url = "https://files.pythonhosted.org/packages/42/95/bb63f0fd62e554fe078e1fb3c8fe9083c14ddc7ad7fa178d10e57e071ac7/lxml-6.1.1-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:c921ba5c51e4e9f63b8b00267d06566e1f63407408a0496da2d1d0bfc819c7fc", size = 4930746, upload-time = "2026-05-18T19:18:29.637Z" }, @@ -24210,6 +24209,7 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/65/d1/bc0ed2427bf609f2ee10da303a6a226f9c8bce94f945dc29a32ce55de6e4/lxml-6.1.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:aa366a1e55b8ebfe8ca8ddc3cfe75c8ebade181aeb0f661d0cb05986b647f72a", size = 5260995, upload-time = "2026-05-18T19:18:37.091Z" }, { url = "https://files.pythonhosted.org/packages/69/8b/6772e1a4b513fc50a8d931f19edde0e13ae6918510a1e13ff67864f3e5ed/lxml-6.1.1-cp312-cp312-win32.whl", hash = "sha256:126c93f7f56f0eda92f6d8c619edc463a4f23d9252f1c9d0405a76f25fa9f11a", size = 3596382, upload-time = "2026-05-18T19:17:18.37Z" }, { url = "https://files.pythonhosted.org/packages/1b/89/45198e9624762af2dfd2cb8782598477ceb29f6e59caab560388ae1f4ec1/lxml-6.1.1-cp312-cp312-win_amd64.whl", hash = "sha256:26e6eda8d38c1fcab1090dd196ee87cbd13788e531937610e2589085de074e77", size = 3997255, upload-time = "2026-05-18T19:17:56.781Z" }, + { url = "https://files.pythonhosted.org/packages/90/a9/7a54b6834088d9ae528a7b780584ba6a39a9457b0ac330479f20ffbc9449/lxml-6.1.1-cp312-cp312-win_arm64.whl", hash = "sha256:6540377fbd53fe1b629172288c464fb18db11ce1fa7dc15891da10aa9dcc3e7f", size = 3659610, upload-time = "2026-05-19T19:22:50.843Z" }, { url = "https://files.pythonhosted.org/packages/a5/eb/7e6f37c5584ccbb2ff267f56fd0339016938c1c8684cfefab9b33ffc2f36/lxml-6.1.1-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:68a9198d0fc122d14bb76837de9aa80cf84caed990b5b237f532ed87d3706736", size = 8559780, upload-time = "2026-05-18T19:17:57.661Z" }, { url = "https://files.pythonhosted.org/packages/a1/36/587c2521cf23a2cd6c9c22108aa7528f683a1f195ed7ccd23a4b1786ad36/lxml-6.1.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:7d47866cb32fb503450b6edc9df355d10dc49836af2e89901bd6ac6b0896d9d9", size = 4618006, upload-time = "2026-05-18T19:18:04.452Z" }, { url = "https://files.pythonhosted.org/packages/6e/ca/ab7bfe2bf4c972af5e7878262845ead3a24a929a9b04bc11c7c1ece6c82a/lxml-6.1.1-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:eb7c9811bfaa8b1ed5ed319f5d370dfbcaa59d52ea64be2a5a85e18195930354", size = 4924139, upload-time = "2026-05-18T19:19:04.873Z" }, @@ -24227,6 +24227,7 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/4d/f8/f6a5e8185bcb28c2befae3d31f8e3df3b811cb0f47746517a81279fcafe1/lxml-6.1.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:47402e62c52ff5988c1e8c6c63177f5708bccf48e366dea4e3dcf1e645e04947", size = 5250276, upload-time = "2026-05-18T19:19:03.834Z" }, { url = "https://files.pythonhosted.org/packages/c7/f2/1a2b9f1b7a49d45495369be7ef9ad05b262930f2eab3e3145706fca8083f/lxml-6.1.1-cp313-cp313-win32.whl", hash = "sha256:3483644525531e1d5762b0c44a8e18b6efba321b6dcf8a8952de10b037618bca", size = 3596903, upload-time = "2026-05-18T19:17:29.863Z" }, { url = "https://files.pythonhosted.org/packages/e6/99/f4ffb024f238eec2131aaa09f3278fb6129cf892741bf68e1fc1afb8c100/lxml-6.1.1-cp313-cp313-win_amd64.whl", hash = "sha256:a10bd2fd62e8ce916ececb342f348f190724a098c1faa056fdfb2a22ad5e8660", size = 3995869, upload-time = "2026-05-18T19:18:02.596Z" }, + { url = "https://files.pythonhosted.org/packages/d1/53/70eb8c5c6037f27448f1e3c54ebede9545a801ae63f0a7254afca4fe8e45/lxml-6.1.1-cp313-cp313-win_arm64.whl", hash = "sha256:424aa57aca0897eb922aef34395bd1289b3b6f04e6bae20ea123c0c7e333cffc", size = 3658490, upload-time = "2026-05-19T19:22:53.846Z" }, { url = "https://files.pythonhosted.org/packages/e7/90/2a23efb250167769570750e65468b787e7df1ea78260e98a33329f68ac64/lxml-6.1.1-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:6689e828a94eee4f139408c337bb198e014724bb8a8c26d3cfac49d119ed69a6", size = 4705505, upload-time = "2026-05-18T19:18:50.286Z" }, { url = "https://files.pythonhosted.org/packages/84/bf/258ecb6dbd35379cae904d92402e92668911e4369af36655a9406dd0d4d6/lxml-6.1.1-cp38-cp38-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:bdebcc8a75d38c7598dfb2c9ed852d7a9eb4a10d6e2d0764b919b802bf32ac88", size = 5074417, upload-time = "2026-05-18T19:20:16.859Z" }, { url = "https://files.pythonhosted.org/packages/de/dc/eff216d79b7660f0a57d1c11b0b5de7e7ee8e0e5edb300d978257edad662/lxml-6.1.1-cp38-cp38-manylinux_2_26_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:8be8ad51249698103d24b0571df35a10990fbe93dd043b6c024172189485f5e3", size = 5220272, upload-time = "2026-05-18T19:20:19.363Z" }, @@ -24249,6 +24250,7 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/69/93/e89fcb55d12b8e1473ce9a62b8f6ee215c89532f7a75a7ce55830834373b/lxml-6.1.1-cp39-cp39-musllinux_1_2_x86_64.whl", hash = "sha256:c9a4b821dc7055bf9e05ff5719e18ec501f75c0f0bbfabd573b277559780833d", size = 5315355, upload-time = "2026-05-18T19:19:51.077Z" }, { url = "https://files.pythonhosted.org/packages/ff/c1/4f07e22d26e2e1ad741666f768df2d3b18ff1ddab3a99e2cb35d5b5df3a3/lxml-6.1.1-cp39-cp39-win32.whl", hash = "sha256:639f6c857d91d9be29bd7502348d6736dab168b54b5158cd899abf11684dc186", size = 3601121, upload-time = "2026-05-18T19:17:58.57Z" }, { url = "https://files.pythonhosted.org/packages/1e/49/4bcb779b303876f1750eb37f534230ef4e7221341826cbd5e42388087393/lxml-6.1.1-cp39-cp39-win_amd64.whl", hash = "sha256:34c2d737beabfe35baada43941ed519251e9a12e779031496bcd5d539fcfd730", size = 4024637, upload-time = "2026-05-18T19:18:32.806Z" }, + { url = "https://files.pythonhosted.org/packages/d8/e6/0d1b437d0783874ff15fb94be03045bce6dcefbce1ea22e44a2dbd59a902/lxml-6.1.1-cp39-cp39-win_arm64.whl", hash = "sha256:07a4a68e286ee7a1ed7dfb8af83e615757c0ccfe9f18c6b4ea6771388d9ba8c9", size = 3670865, upload-time = "2026-05-19T19:23:01.555Z" }, { url = "https://files.pythonhosted.org/packages/b5/32/86a3f0f724a3a402d4627937a7fc27b160e45e7012b4adf47f6e1e844511/lxml-6.1.1-pp311-pypy311_pp73-macosx_10_15_x86_64.whl", hash = "sha256:31033dc34636ea6b7d5cc11b1ddbda78a14de858ba9d3e1ed4b69a3085bc521e", size = 3930127, upload-time = "2026-05-18T19:19:02.27Z" }, { url = "https://files.pythonhosted.org/packages/40/44/d832e82af08723761556d004b1d04d281c09f9a8cecd7d3148548c9941a3/lxml-6.1.1-pp311-pypy311_pp73-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:3893c14c4b6ac5b2d54ba8cf03e99fe5104e592de491f19bd6b82756c09f8004", size = 4210769, upload-time = "2026-05-18T19:20:41.427Z" }, { url = "https://files.pythonhosted.org/packages/6d/39/0dc5949f759ed7d951e0bb8c2f2d9d7aca1908d22352fa84a8afd2ea54af/lxml-6.1.1-pp311-pypy311_pp73-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:c07da4cebf6889f03ebac8d238f62318e29f495de0aa18a51ea14e61ae907e2e", size = 4318163, upload-time = "2026-05-18T19:20:44.702Z" }, @@ -31704,7 +31706,7 @@ name = "nvidia-cublas" version = "13.1.1.3" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "nvidia-cuda-nvrtc", marker = "(python_full_version >= '3.10' and python_full_version < '3.12' and extra == 'group-13-lightly-train-minimal-torch') or (python_full_version >= '3.10' and python_full_version < '3.12' and extra != 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version < '3.10' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version < '3.10' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version < '3.10' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.12' and extra == 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch') or (python_full_version >= '3.12' and extra == 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.12' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.12' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (extra != 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal')" }, + { name = "nvidia-cuda-nvrtc", marker = "(python_full_version >= '3.10' and python_full_version < '3.12' and sys_platform == 'linux' and extra == 'group-13-lightly-train-minimal-torch') or (python_full_version >= '3.10' and python_full_version < '3.12' and sys_platform == 'linux' and extra != 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version < '3.12' and sys_platform != 'linux' and extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version < '3.12' and sys_platform != 'linux' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version < '3.12' and sys_platform != 'linux' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version < '3.12' and sys_platform != 'linux' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version < '3.12' and sys_platform != 'linux' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version < '3.12' and sys_platform != 'linux' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.12' and sys_platform != 'win32' and extra == 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch') or (python_full_version >= '3.12' and sys_platform != 'win32' and extra == 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version < '3.10' and sys_platform == 'linux' and extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version < '3.10' and sys_platform == 'linux' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version < '3.10' and sys_platform == 'linux' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version < '3.10' and sys_platform == 'linux' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version < '3.10' and sys_platform == 'linux' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version < '3.10' and sys_platform == 'linux' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.12' and sys_platform == 'linux' and extra == 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch') or (python_full_version >= '3.12' and sys_platform == 'linux' and extra == 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.10' and extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version >= '3.10' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version >= '3.10' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version >= '3.12' and extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version >= '3.12' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version >= '3.12' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version >= '3.12' and extra == 'extra-13-lightly-train-onnx' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.12' and extra == 'extra-13-lightly-train-onnx' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.12' and extra == 'extra-13-lightly-train-onnx' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.12' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.12' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.12' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.12' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.12' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.12' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.10' and extra != 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.12' and extra != 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.12' and extra != 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.12' and extra != 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (sys_platform == 'win32' and extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (sys_platform == 'win32' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (sys_platform == 'win32' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (sys_platform == 'win32' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (sys_platform == 'win32' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (sys_platform == 'win32' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal')" }, ] wheels = [ { url = "https://files.pythonhosted.org/packages/a7/a1/0bd24ee8c8d03adac032fd2909426a00c88f8c57961b1277ded97f91119f/nvidia_cublas-13.1.1.3-py3-none-manylinux_2_27_aarch64.whl", hash = "sha256:b7a210458267ac818974c53038fbec2e969d5c99f305ab15c72522fa9f001dd5", size = 542848918, upload-time = "2026-04-08T18:46:22.985Z" }, @@ -31899,7 +31901,7 @@ name = "nvidia-cudnn-cu11" version = "9.1.0.70" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "nvidia-cublas-cu11", marker = "(python_full_version < '3.9' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.9' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal')" }, + { name = "nvidia-cublas-cu11", marker = "(python_full_version >= '3.9' and python_full_version < '3.12' and platform_machine == 's390x' and sys_platform == 'linux' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.9' and platform_machine != 'aarch64' and platform_machine != 's390x' and sys_platform == 'linux' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.12' and platform_machine != 's390x' and sys_platform != 'darwin' and sys_platform != 'linux' and sys_platform != 'win32' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version < '3.12' and platform_machine != 's390x' and sys_platform != 'linux' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version < '3.12' and platform_machine != 's390x' and sys_platform != 'linux' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version < '3.12' and platform_machine != 's390x' and sys_platform != 'linux' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.12' and platform_machine != 's390x' and sys_platform == 'darwin' and extra == 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.12' and platform_machine == 'aarch64' and sys_platform == 'linux' and extra == 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version < '3.12' and platform_machine == 'aarch64' and sys_platform == 'linux' and extra != 'extra-13-lightly-train-onnx' and extra != 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-rfdetr' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.12' and platform_machine == 's390x' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version < '3.12' and sys_platform == 'darwin' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version < '3.9' and sys_platform == 'linux' and extra == 'extra-13-lightly-train-onnx' and extra != 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version < '3.9' and sys_platform == 'linux' and extra == 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version < '3.9' and sys_platform == 'linux' and extra == 'extra-13-lightly-train-rfdetr' and extra != 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version < '3.9' and sys_platform == 'linux' and extra != 'extra-13-lightly-train-onnx' and extra != 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-rfdetr' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version < '3.9' and sys_platform == 'linux' and extra != 'extra-13-lightly-train-onnx' and extra != 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-rfdetr' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (platform_machine != 'aarch64' and platform_machine != 's390x' and sys_platform == 'linux' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (platform_machine != 'aarch64' and platform_machine != 's390x' and sys_platform == 'linux' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (platform_machine != 'aarch64' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (platform_machine != 'aarch64' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (platform_machine != 'aarch64' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (platform_machine != 'aarch64' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-onnx' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (platform_machine != 'aarch64' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-onnx' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (platform_machine != 'aarch64' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (platform_machine != 'aarch64' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (platform_machine != 'aarch64' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (platform_machine != 'aarch64' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (platform_machine != 's390x' and sys_platform != 'darwin' and sys_platform != 'linux' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (platform_machine != 's390x' and sys_platform != 'darwin' and sys_platform != 'linux' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (platform_machine == 's390x' and sys_platform != 'linux' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (platform_machine == 's390x' and sys_platform == 'darwin' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (platform_machine == 'aarch64' and sys_platform == 'linux' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (platform_machine == 'aarch64' and sys_platform == 'linux' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (platform_machine == 'aarch64' and sys_platform == 'linux' and extra == 'extra-13-lightly-train-onnx' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (platform_machine == 'aarch64' and sys_platform == 'linux' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (platform_machine == 'aarch64' and sys_platform == 'linux' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (platform_machine == 'aarch64' and sys_platform == 'linux' and extra != 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (platform_machine == 'aarch64' and extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (platform_machine == 'aarch64' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (platform_machine == 'aarch64' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (platform_machine == 's390x' and extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (platform_machine == 's390x' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (platform_machine == 's390x' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (platform_machine == 's390x' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (platform_machine == 's390x' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (platform_machine == 'aarch64' and extra == 'extra-13-lightly-train-onnx' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (platform_machine == 'aarch64' and extra == 'extra-13-lightly-train-onnx' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (platform_machine == 'aarch64' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (platform_machine == 'aarch64' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (platform_machine == 'aarch64' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (platform_machine == 'aarch64' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (sys_platform != 'linux' and extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (sys_platform != 'linux' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (sys_platform != 'linux' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (sys_platform == 'darwin' and extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (sys_platform == 'darwin' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (sys_platform == 'darwin' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (sys_platform == 'darwin' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (sys_platform == 'darwin' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (sys_platform == 'win32' and extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (sys_platform == 'win32' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (sys_platform == 'win32' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (sys_platform == 'win32' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (sys_platform == 'win32' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (sys_platform == 'win32' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (sys_platform != 'linux' and extra == 'extra-13-lightly-train-onnx' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (sys_platform != 'linux' and extra == 'extra-13-lightly-train-onnx' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (sys_platform != 'linux' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (sys_platform != 'linux' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (sys_platform != 'linux' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (sys_platform != 'linux' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (sys_platform == 'darwin' and extra == 'extra-13-lightly-train-onnx' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (sys_platform == 'darwin' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (sys_platform == 'darwin' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (sys_platform == 'darwin' and extra != 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal')" }, ] wheels = [ { url = "https://files.pythonhosted.org/packages/00/3b/0b776f04e364cd99e4cf152c2a9eadb5934c67c9a91429da55169a9447fd/nvidia_cudnn_cu11-9.1.0.70-py3-none-manylinux2014_x86_64.whl", hash = "sha256:e6135ac63fe9d5b0b89cfb35c3fc1c1349f2b995becadf2e9dc21bca89d9633d", size = 663919573, upload-time = "2024-04-22T15:20:24.839Z" }, @@ -31914,7 +31916,7 @@ resolution-markers = [ "python_full_version < '3.9' and sys_platform == 'linux'", ] dependencies = [ - { name = "nvidia-cublas-cu12", version = "12.1.3.1", source = { registry = "https://pypi.org/simple" }, marker = "(python_full_version < '3.9' and extra == 'group-13-lightly-train-minimal-torch') or (extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal')" }, + { name = "nvidia-cublas-cu12", version = "12.1.3.1", source = { registry = "https://pypi.org/simple" }, marker = "(python_full_version < '3.9' and sys_platform == 'linux' and extra == 'group-13-lightly-train-minimal-torch') or (python_full_version >= '3.9' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.9' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (sys_platform != 'linux' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (sys_platform != 'linux' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (sys_platform != 'linux' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (extra != 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal')" }, ] wheels = [ { url = "https://files.pythonhosted.org/packages/ff/74/a2e2be7fb83aaedec84f391f082cf765dfb635e7caa9b49065f73e4835d8/nvidia_cudnn_cu12-8.9.2.26-py3-none-manylinux1_x86_64.whl", hash = "sha256:5ccb288774fdfb07a7e7025ffec286971c06d8d7b4fb162525334616d7629ff9", size = 731725872, upload-time = "2023-06-01T19:24:57.328Z" }, @@ -31928,7 +31930,7 @@ resolution-markers = [ "python_full_version < '3.9' and sys_platform == 'linux'", ] dependencies = [ - { name = "nvidia-cublas-cu12", version = "12.1.3.1", source = { registry = "https://pypi.org/simple" }, marker = "(python_full_version < '3.9' and sys_platform != 'win32' and extra != 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version < '3.9' and sys_platform != 'win32' and extra != 'group-13-lightly-train-minimal-torch' and extra != 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version < '3.9' and extra == 'extra-13-lightly-train-onnx' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version < '3.9' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version < '3.9' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version < '3.9' and extra != 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.9' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version < '3.9' and extra == 'extra-13-lightly-train-onnx' and extra != 'group-13-lightly-train-minimal-torch' and extra != 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version < '3.9' and extra == 'extra-13-lightly-train-onnxruntime' and extra != 'group-13-lightly-train-minimal-torch' and extra != 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version < '3.9' and extra == 'extra-13-lightly-train-rfdetr' and extra != 'group-13-lightly-train-minimal-torch' and extra != 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version < '3.9' and extra != 'group-13-lightly-train-minimal-torch' and extra != 'group-13-lightly-train-pinned-torch-maximal' and extra != 'group-13-lightly-train-pinned-torch-minimal') or (extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (extra == 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (extra == 'extra-13-lightly-train-onnx' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (extra == 'extra-13-lightly-train-onnxruntime' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (extra == 'extra-13-lightly-train-rfdetr' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal')" }, + { name = "nvidia-cublas-cu12", version = "12.1.3.1", source = { registry = "https://pypi.org/simple" }, marker = "(python_full_version < '3.9' and sys_platform == 'linux' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version < '3.9' and sys_platform == 'linux' and extra != 'group-13-lightly-train-minimal-torch' and extra != 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.9' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (sys_platform != 'linux' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal')" }, ] wheels = [ { url = "https://files.pythonhosted.org/packages/9f/fd/713452cd72343f682b1c7b9321e23829f00b842ceaedcda96e742ea0b0b3/nvidia_cudnn_cu12-9.1.0.70-py3-none-manylinux2014_x86_64.whl", hash = "sha256:165764f44ef8c61fcdfdfdbe769d687e06374059fbb388b6c89ecb0e28793a6f", size = 664752741, upload-time = "2024-04-22T15:24:15.253Z" }, @@ -31945,7 +31947,7 @@ resolution-markers = [ "(python_full_version == '3.12.*' and platform_machine != 'aarch64' and platform_machine != 's390x' and sys_platform == 'linux') or (python_full_version == '3.12.*' and platform_machine != 's390x' and sys_platform != 'darwin' and sys_platform != 'linux' and sys_platform != 'win32')", ] dependencies = [ - { name = "nvidia-cublas-cu12", version = "12.8.4.1", source = { registry = "https://pypi.org/simple" }, marker = "(python_full_version >= '3.10' and python_full_version < '3.12' and platform_machine != 's390x' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.10' and python_full_version < '3.12' and platform_machine != 's390x' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.10' and python_full_version < '3.12' and platform_machine != 's390x' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version < '3.9' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version < '3.9' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version < '3.9' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version < '3.9' and platform_machine != 's390x' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version < '3.9' and platform_machine != 's390x' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version < '3.9' and platform_machine != 's390x' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.10' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version >= '3.10' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version >= '3.10' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version >= '3.12' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version >= '3.12' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-onnx' and extra == 'group-13-lightly-train-minimal-torch') or (python_full_version >= '3.12' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-onnx' and extra != 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.12' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version >= '3.12' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'group-13-lightly-train-minimal-torch') or (python_full_version >= '3.12' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-onnxruntime' and extra != 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.12' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version >= '3.12' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'group-13-lightly-train-minimal-torch') or (python_full_version >= '3.12' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-rfdetr' and extra != 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.12' and platform_machine != 's390x' and extra != 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch') or (python_full_version >= '3.12' and platform_machine != 's390x' and extra != 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.10' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-onnx' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.10' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-onnx' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.10' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-onnx' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.10' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.10' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.10' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.10' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.10' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.10' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.12' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-onnx' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.12' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.12' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.12' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.12' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.12' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.12' and platform_machine != 's390x' and extra != 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version == '3.9.*' and extra == 'group-13-lightly-train-minimal-torch') or (python_full_version == '3.9.*' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version == '3.9.*' and extra != 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version == '3.9.*' and extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version == '3.9.*' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version == '3.9.*' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (platform_machine == 's390x' and extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (platform_machine == 's390x' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (platform_machine == 's390x' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (platform_machine == 's390x' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (platform_machine == 's390x' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (platform_machine == 's390x' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal')" }, + { name = "nvidia-cublas-cu12", version = "12.8.4.1", source = { registry = "https://pypi.org/simple" }, marker = "(python_full_version >= '3.10' and python_full_version < '3.12' and platform_machine != 'aarch64' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version >= '3.10' and python_full_version < '3.12' and platform_machine != 'aarch64' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version >= '3.10' and python_full_version < '3.12' and platform_machine != 'aarch64' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version >= '3.10' and python_full_version < '3.12' and platform_machine != 'aarch64' and platform_machine != 's390x' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.10' and python_full_version < '3.12' and platform_machine != 'aarch64' and platform_machine != 's390x' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.10' and python_full_version < '3.12' and platform_machine != 'aarch64' and platform_machine != 's390x' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.12' and platform_machine != 'aarch64' and platform_machine != 's390x' and sys_platform == 'linux' and extra == 'extra-13-lightly-train-onnx' and extra == 'group-13-lightly-train-minimal-torch') or (python_full_version >= '3.12' and platform_machine != 'aarch64' and platform_machine != 's390x' and sys_platform == 'linux' and extra == 'extra-13-lightly-train-onnx' and extra != 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.12' and platform_machine != 'aarch64' and platform_machine != 's390x' and sys_platform == 'linux' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'group-13-lightly-train-minimal-torch') or (python_full_version >= '3.12' and platform_machine != 'aarch64' and platform_machine != 's390x' and sys_platform == 'linux' and extra == 'extra-13-lightly-train-onnxruntime' and extra != 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.12' and platform_machine != 'aarch64' and platform_machine != 's390x' and sys_platform == 'linux' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'group-13-lightly-train-minimal-torch') or (python_full_version >= '3.12' and platform_machine != 'aarch64' and platform_machine != 's390x' and sys_platform == 'linux' and extra == 'extra-13-lightly-train-rfdetr' and extra != 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.12' and platform_machine != 'aarch64' and platform_machine != 's390x' and sys_platform == 'linux' and extra != 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch') or (python_full_version >= '3.12' and platform_machine != 'aarch64' and platform_machine != 's390x' and sys_platform == 'linux' and extra != 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version < '3.9' and platform_machine != 'aarch64' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version < '3.9' and platform_machine != 'aarch64' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version < '3.9' and platform_machine != 'aarch64' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version == '3.9.*' and platform_machine != 'aarch64' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version == '3.9.*' and platform_machine != 'aarch64' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version == '3.9.*' and platform_machine != 'aarch64' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version >= '3.12' and platform_machine != 'aarch64' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version >= '3.12' and platform_machine != 'aarch64' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version >= '3.12' and platform_machine != 'aarch64' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version < '3.9' and platform_machine != 'aarch64' and platform_machine != 's390x' and extra != 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version == '3.9.*' and platform_machine != 'aarch64' and platform_machine != 's390x' and extra != 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.12' and platform_machine != 'aarch64' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.12' and platform_machine != 'aarch64' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.12' and platform_machine != 'aarch64' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.12' and platform_machine != 'aarch64' and platform_machine != 's390x' and extra != 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.12' and platform_machine != 's390x' and sys_platform != 'darwin' and sys_platform != 'linux' and sys_platform != 'win32' and extra == 'extra-13-lightly-train-onnx' and extra == 'group-13-lightly-train-minimal-torch') or (python_full_version >= '3.12' and platform_machine != 's390x' and sys_platform != 'darwin' and sys_platform != 'linux' and sys_platform != 'win32' and extra == 'extra-13-lightly-train-onnx' and extra != 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.12' and platform_machine != 's390x' and sys_platform != 'darwin' and sys_platform != 'linux' and sys_platform != 'win32' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'group-13-lightly-train-minimal-torch') or (python_full_version >= '3.12' and platform_machine != 's390x' and sys_platform != 'darwin' and sys_platform != 'linux' and sys_platform != 'win32' and extra == 'extra-13-lightly-train-onnxruntime' and extra != 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.12' and platform_machine != 's390x' and sys_platform != 'darwin' and sys_platform != 'linux' and sys_platform != 'win32' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'group-13-lightly-train-minimal-torch') or (python_full_version >= '3.12' and platform_machine != 's390x' and sys_platform != 'darwin' and sys_platform != 'linux' and sys_platform != 'win32' and extra == 'extra-13-lightly-train-rfdetr' and extra != 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.12' and platform_machine != 's390x' and sys_platform != 'darwin' and sys_platform != 'linux' and sys_platform != 'win32' and extra != 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch') or (python_full_version >= '3.12' and platform_machine != 's390x' and sys_platform != 'darwin' and sys_platform != 'linux' and sys_platform != 'win32' and extra != 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version == '3.9.*' and platform_machine == 's390x' and sys_platform == 'linux' and extra == 'group-13-lightly-train-minimal-torch') or (python_full_version == '3.9.*' and platform_machine == 's390x' and sys_platform == 'linux' and extra != 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version < '3.12' and platform_machine != 's390x' and sys_platform != 'linux' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version < '3.12' and platform_machine != 's390x' and sys_platform != 'linux' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version < '3.12' and platform_machine != 's390x' and sys_platform != 'linux' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version == '3.9.*' and platform_machine != 'aarch64' and sys_platform == 'linux' and extra == 'extra-13-lightly-train-onnx' and extra != 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch') or (python_full_version == '3.9.*' and platform_machine != 'aarch64' and sys_platform == 'linux' and extra == 'extra-13-lightly-train-onnx' and extra != 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version == '3.9.*' and platform_machine != 'aarch64' and sys_platform == 'linux' and extra == 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch') or (python_full_version == '3.9.*' and platform_machine != 'aarch64' and sys_platform == 'linux' and extra == 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version == '3.9.*' and platform_machine != 'aarch64' and sys_platform == 'linux' and extra == 'extra-13-lightly-train-rfdetr' and extra != 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch') or (python_full_version == '3.9.*' and platform_machine != 'aarch64' and sys_platform == 'linux' and extra == 'extra-13-lightly-train-rfdetr' and extra != 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version < '3.9' and platform_machine != 's390x' and sys_platform == 'linux' and extra == 'extra-13-lightly-train-onnx' and extra != 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version < '3.9' and platform_machine != 's390x' and sys_platform == 'linux' and extra == 'extra-13-lightly-train-onnx' and extra != 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version < '3.9' and platform_machine != 's390x' and sys_platform == 'linux' and extra == 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version < '3.9' and platform_machine != 's390x' and sys_platform == 'linux' and extra == 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version < '3.9' and platform_machine != 's390x' and sys_platform == 'linux' and extra == 'extra-13-lightly-train-rfdetr' and extra != 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version < '3.9' and platform_machine != 's390x' and sys_platform == 'linux' and extra == 'extra-13-lightly-train-rfdetr' and extra != 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version == '3.9.*' and platform_machine != 'aarch64' and sys_platform == 'linux' and extra != 'extra-13-lightly-train-onnx' and extra != 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-rfdetr' and extra == 'group-13-lightly-train-minimal-torch') or (python_full_version == '3.9.*' and platform_machine != 'aarch64' and sys_platform == 'linux' and extra != 'extra-13-lightly-train-onnx' and extra != 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-rfdetr' and extra != 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version < '3.9' and platform_machine != 's390x' and sys_platform == 'linux' and extra != 'extra-13-lightly-train-onnx' and extra != 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-rfdetr' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version < '3.9' and platform_machine != 's390x' and sys_platform == 'linux' and extra != 'extra-13-lightly-train-onnx' and extra != 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-rfdetr' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version != '3.9.*' and platform_machine == 's390x' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version != '3.9.*' and platform_machine == 's390x' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version != '3.9.*' and platform_machine == 's390x' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (platform_machine == 's390x' and sys_platform != 'linux' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (platform_machine == 's390x' and sys_platform != 'linux' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (platform_machine == 'aarch64' and sys_platform == 'linux' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (platform_machine == 'aarch64' and sys_platform == 'linux' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (platform_machine != 's390x' and sys_platform != 'linux' and extra == 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (platform_machine != 's390x' and sys_platform != 'linux' and extra == 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (platform_machine != 's390x' and sys_platform != 'linux' and extra == 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (platform_machine == 'aarch64' and extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (platform_machine == 'aarch64' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (platform_machine == 'aarch64' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (platform_machine == 's390x' and extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (platform_machine == 's390x' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (platform_machine == 's390x' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (platform_machine == 'aarch64' and extra != 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (platform_machine == 's390x' and extra != 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (sys_platform != 'linux' and extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (sys_platform != 'linux' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (sys_platform != 'linux' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (sys_platform == 'darwin' and extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (sys_platform == 'darwin' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (sys_platform == 'darwin' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (sys_platform == 'darwin' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (sys_platform == 'darwin' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (sys_platform == 'darwin' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (sys_platform == 'win32' and extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (sys_platform == 'win32' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (sys_platform == 'win32' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (sys_platform == 'win32' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (sys_platform == 'win32' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (sys_platform == 'win32' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (sys_platform != 'linux' and extra != 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal')" }, ] wheels = [ { url = "https://files.pythonhosted.org/packages/fa/41/e79269ce215c857c935fd86bcfe91a451a584dfc27f1e068f568b9ad1ab7/nvidia_cudnn_cu12-9.10.2.21-py3-none-manylinux_2_27_aarch64.whl", hash = "sha256:c9132cc3f8958447b4910a1720036d9eff5928cc3179b0a51fb6d167c6cc87d8", size = 705026878, upload-time = "2025-06-06T21:52:51.348Z" }, @@ -31958,7 +31960,7 @@ name = "nvidia-cudnn-cu13" version = "9.20.0.48" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "nvidia-cublas", marker = "(python_full_version >= '3.10' and python_full_version < '3.12' and extra == 'group-13-lightly-train-minimal-torch') or (python_full_version >= '3.10' and python_full_version < '3.12' and extra != 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version < '3.10' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version < '3.10' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version < '3.10' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.12' and extra == 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch') or (python_full_version >= '3.12' and extra == 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.12' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.12' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (extra != 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal')" }, + { name = "nvidia-cublas", marker = "(python_full_version >= '3.10' and python_full_version < '3.12' and sys_platform == 'linux' and extra == 'group-13-lightly-train-minimal-torch') or (python_full_version >= '3.10' and python_full_version < '3.12' and sys_platform == 'linux' and extra != 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version < '3.12' and sys_platform != 'linux' and extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version < '3.12' and sys_platform != 'linux' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version < '3.12' and sys_platform != 'linux' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version < '3.12' and sys_platform != 'linux' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version < '3.12' and sys_platform != 'linux' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version < '3.12' and sys_platform != 'linux' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.12' and sys_platform != 'win32' and extra == 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch') or (python_full_version >= '3.12' and sys_platform != 'win32' and extra == 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version < '3.10' and sys_platform == 'linux' and extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version < '3.10' and sys_platform == 'linux' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version < '3.10' and sys_platform == 'linux' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version < '3.10' and sys_platform == 'linux' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version < '3.10' and sys_platform == 'linux' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version < '3.10' and sys_platform == 'linux' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.12' and sys_platform == 'linux' and extra == 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch') or (python_full_version >= '3.12' and sys_platform == 'linux' and extra == 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.10' and extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version >= '3.10' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version >= '3.10' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version >= '3.12' and extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version >= '3.12' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version >= '3.12' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version >= '3.12' and extra == 'extra-13-lightly-train-onnx' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.12' and extra == 'extra-13-lightly-train-onnx' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.12' and extra == 'extra-13-lightly-train-onnx' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.12' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.12' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.12' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.12' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.12' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.12' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.10' and extra != 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.12' and extra != 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.12' and extra != 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.12' and extra != 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (sys_platform == 'win32' and extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (sys_platform == 'win32' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (sys_platform == 'win32' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (sys_platform == 'win32' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (sys_platform == 'win32' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (sys_platform == 'win32' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal')" }, ] wheels = [ { url = "https://files.pythonhosted.org/packages/56/c5/83384d846b2fd17c44bd499b36c75a45ed4f095fbbb2252294e89cea5c5c/nvidia_cudnn_cu13-9.20.0.48-py3-none-manylinux_2_27_aarch64.whl", hash = "sha256:e31454ae00094b0c55319d9d15b6fa2fc50a9e1c0f5c8c80fb75258234e731e1", size = 444574296, upload-time = "2026-03-09T19:28:27.751Z" }, @@ -31971,7 +31973,7 @@ name = "nvidia-cufft" version = "12.0.0.61" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "nvidia-nvjitlink", marker = "(python_full_version >= '3.10' and python_full_version < '3.12' and extra == 'group-13-lightly-train-minimal-torch') or (python_full_version >= '3.10' and python_full_version < '3.12' and extra != 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version < '3.10' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version < '3.10' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version < '3.10' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.12' and extra == 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch') or (python_full_version >= '3.12' and extra == 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.12' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.12' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (extra != 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal')" }, + { name = "nvidia-nvjitlink", marker = "(python_full_version >= '3.10' and python_full_version < '3.12' and sys_platform == 'linux' and extra == 'group-13-lightly-train-minimal-torch') or (python_full_version >= '3.10' and python_full_version < '3.12' and sys_platform == 'linux' and extra != 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version < '3.12' and sys_platform != 'linux' and extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version < '3.12' and sys_platform != 'linux' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version < '3.12' and sys_platform != 'linux' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version < '3.12' and sys_platform != 'linux' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version < '3.12' and sys_platform != 'linux' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version < '3.12' and sys_platform != 'linux' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.12' and sys_platform != 'win32' and extra == 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch') or (python_full_version >= '3.12' and sys_platform != 'win32' and extra == 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version < '3.10' and sys_platform == 'linux' and extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version < '3.10' and sys_platform == 'linux' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version < '3.10' and sys_platform == 'linux' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version < '3.10' and sys_platform == 'linux' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version < '3.10' and sys_platform == 'linux' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version < '3.10' and sys_platform == 'linux' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.12' and sys_platform == 'linux' and extra == 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch') or (python_full_version >= '3.12' and sys_platform == 'linux' and extra == 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.10' and extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version >= '3.10' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version >= '3.10' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version >= '3.12' and extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version >= '3.12' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version >= '3.12' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version >= '3.12' and extra == 'extra-13-lightly-train-onnx' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.12' and extra == 'extra-13-lightly-train-onnx' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.12' and extra == 'extra-13-lightly-train-onnx' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.12' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.12' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.12' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.12' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.12' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.12' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.10' and extra != 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.12' and extra != 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.12' and extra != 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.12' and extra != 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (sys_platform == 'win32' and extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (sys_platform == 'win32' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (sys_platform == 'win32' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (sys_platform == 'win32' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (sys_platform == 'win32' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (sys_platform == 'win32' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal')" }, ] wheels = [ { url = "https://files.pythonhosted.org/packages/8b/ae/f417a75c0259e85c1d2f83ca4e960289a5f814ed0cea74d18c353d3e989d/nvidia_cufft-12.0.0.61-py3-none-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:2708c852ef8cd89d1d2068bdbece0aa188813a0c934db3779b9b1faa8442e5f5", size = 214053554, upload-time = "2025-09-04T08:31:38.196Z" }, @@ -32012,7 +32014,7 @@ resolution-markers = [ "(python_full_version == '3.12.*' and platform_machine != 'aarch64' and platform_machine != 's390x' and sys_platform == 'linux') or (python_full_version == '3.12.*' and platform_machine != 's390x' and sys_platform != 'darwin' and sys_platform != 'linux' and sys_platform != 'win32')", ] dependencies = [ - { name = "nvidia-nvjitlink-cu12", marker = "(python_full_version >= '3.10' and python_full_version < '3.12' and platform_machine != 's390x' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.10' and python_full_version < '3.12' and platform_machine != 's390x' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.10' and python_full_version < '3.12' and platform_machine != 's390x' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version < '3.9' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version < '3.9' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version < '3.9' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version < '3.9' and platform_machine != 's390x' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version < '3.9' and platform_machine != 's390x' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version < '3.9' and platform_machine != 's390x' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.10' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version >= '3.10' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version >= '3.10' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version >= '3.12' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version >= '3.12' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-onnx' and extra == 'group-13-lightly-train-minimal-torch') or (python_full_version >= '3.12' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-onnx' and extra != 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.12' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version >= '3.12' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'group-13-lightly-train-minimal-torch') or (python_full_version >= '3.12' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-onnxruntime' and extra != 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.12' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version >= '3.12' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'group-13-lightly-train-minimal-torch') or (python_full_version >= '3.12' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-rfdetr' and extra != 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.12' and platform_machine != 's390x' and extra != 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch') or (python_full_version >= '3.12' and platform_machine != 's390x' and extra != 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.10' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-onnx' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.10' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-onnx' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.10' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-onnx' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.10' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.10' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.10' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.10' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.10' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.10' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.12' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-onnx' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.12' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.12' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.12' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.12' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.12' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.12' and platform_machine != 's390x' and extra != 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version == '3.9.*' and extra == 'group-13-lightly-train-minimal-torch') or (python_full_version == '3.9.*' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version == '3.9.*' and extra != 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version == '3.9.*' and extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version == '3.9.*' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version == '3.9.*' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (platform_machine == 's390x' and extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (platform_machine == 's390x' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (platform_machine == 's390x' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (platform_machine == 's390x' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (platform_machine == 's390x' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (platform_machine == 's390x' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal')" }, + { name = "nvidia-nvjitlink-cu12", marker = "(python_full_version >= '3.10' and python_full_version < '3.12' and platform_machine != 'aarch64' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version >= '3.10' and python_full_version < '3.12' and platform_machine != 'aarch64' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version >= '3.10' and python_full_version < '3.12' and platform_machine != 'aarch64' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version >= '3.10' and python_full_version < '3.12' and platform_machine != 'aarch64' and platform_machine != 's390x' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.10' and python_full_version < '3.12' and platform_machine != 'aarch64' and platform_machine != 's390x' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.10' and python_full_version < '3.12' and platform_machine != 'aarch64' and platform_machine != 's390x' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.12' and platform_machine != 'aarch64' and platform_machine != 's390x' and sys_platform == 'linux' and extra == 'extra-13-lightly-train-onnx' and extra == 'group-13-lightly-train-minimal-torch') or (python_full_version >= '3.12' and platform_machine != 'aarch64' and platform_machine != 's390x' and sys_platform == 'linux' and extra == 'extra-13-lightly-train-onnx' and extra != 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.12' and platform_machine != 'aarch64' and platform_machine != 's390x' and sys_platform == 'linux' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'group-13-lightly-train-minimal-torch') or (python_full_version >= '3.12' and platform_machine != 'aarch64' and platform_machine != 's390x' and sys_platform == 'linux' and extra == 'extra-13-lightly-train-onnxruntime' and extra != 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.12' and platform_machine != 'aarch64' and platform_machine != 's390x' and sys_platform == 'linux' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'group-13-lightly-train-minimal-torch') or (python_full_version >= '3.12' and platform_machine != 'aarch64' and platform_machine != 's390x' and sys_platform == 'linux' and extra == 'extra-13-lightly-train-rfdetr' and extra != 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.12' and platform_machine != 'aarch64' and platform_machine != 's390x' and sys_platform == 'linux' and extra != 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch') or (python_full_version >= '3.12' and platform_machine != 'aarch64' and platform_machine != 's390x' and sys_platform == 'linux' and extra != 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version < '3.9' and platform_machine != 'aarch64' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version < '3.9' and platform_machine != 'aarch64' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version < '3.9' and platform_machine != 'aarch64' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version == '3.9.*' and platform_machine != 'aarch64' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version == '3.9.*' and platform_machine != 'aarch64' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version == '3.9.*' and platform_machine != 'aarch64' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version >= '3.12' and platform_machine != 'aarch64' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version >= '3.12' and platform_machine != 'aarch64' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version >= '3.12' and platform_machine != 'aarch64' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version < '3.9' and platform_machine != 'aarch64' and platform_machine != 's390x' and extra != 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version == '3.9.*' and platform_machine != 'aarch64' and platform_machine != 's390x' and extra != 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.12' and platform_machine != 'aarch64' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.12' and platform_machine != 'aarch64' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.12' and platform_machine != 'aarch64' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.12' and platform_machine != 'aarch64' and platform_machine != 's390x' and extra != 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.12' and platform_machine != 's390x' and sys_platform != 'darwin' and sys_platform != 'linux' and sys_platform != 'win32' and extra == 'extra-13-lightly-train-onnx' and extra == 'group-13-lightly-train-minimal-torch') or (python_full_version >= '3.12' and platform_machine != 's390x' and sys_platform != 'darwin' and sys_platform != 'linux' and sys_platform != 'win32' and extra == 'extra-13-lightly-train-onnx' and extra != 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.12' and platform_machine != 's390x' and sys_platform != 'darwin' and sys_platform != 'linux' and sys_platform != 'win32' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'group-13-lightly-train-minimal-torch') or (python_full_version >= '3.12' and platform_machine != 's390x' and sys_platform != 'darwin' and sys_platform != 'linux' and sys_platform != 'win32' and extra == 'extra-13-lightly-train-onnxruntime' and extra != 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.12' and platform_machine != 's390x' and sys_platform != 'darwin' and sys_platform != 'linux' and sys_platform != 'win32' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'group-13-lightly-train-minimal-torch') or (python_full_version >= '3.12' and platform_machine != 's390x' and sys_platform != 'darwin' and sys_platform != 'linux' and sys_platform != 'win32' and extra == 'extra-13-lightly-train-rfdetr' and extra != 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.12' and platform_machine != 's390x' and sys_platform != 'darwin' and sys_platform != 'linux' and sys_platform != 'win32' and extra != 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch') or (python_full_version >= '3.12' and platform_machine != 's390x' and sys_platform != 'darwin' and sys_platform != 'linux' and sys_platform != 'win32' and extra != 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version == '3.9.*' and platform_machine == 's390x' and sys_platform == 'linux' and extra == 'group-13-lightly-train-minimal-torch') or (python_full_version == '3.9.*' and platform_machine == 's390x' and sys_platform == 'linux' and extra != 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version < '3.12' and platform_machine != 's390x' and sys_platform != 'linux' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version < '3.12' and platform_machine != 's390x' and sys_platform != 'linux' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version < '3.12' and platform_machine != 's390x' and sys_platform != 'linux' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version == '3.9.*' and platform_machine != 'aarch64' and sys_platform == 'linux' and extra == 'extra-13-lightly-train-onnx' and extra != 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch') or (python_full_version == '3.9.*' and platform_machine != 'aarch64' and sys_platform == 'linux' and extra == 'extra-13-lightly-train-onnx' and extra != 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version == '3.9.*' and platform_machine != 'aarch64' and sys_platform == 'linux' and extra == 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch') or (python_full_version == '3.9.*' and platform_machine != 'aarch64' and sys_platform == 'linux' and extra == 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version == '3.9.*' and platform_machine != 'aarch64' and sys_platform == 'linux' and extra == 'extra-13-lightly-train-rfdetr' and extra != 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch') or (python_full_version == '3.9.*' and platform_machine != 'aarch64' and sys_platform == 'linux' and extra == 'extra-13-lightly-train-rfdetr' and extra != 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version < '3.9' and platform_machine != 's390x' and sys_platform == 'linux' and extra == 'extra-13-lightly-train-onnx' and extra != 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version < '3.9' and platform_machine != 's390x' and sys_platform == 'linux' and extra == 'extra-13-lightly-train-onnx' and extra != 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version < '3.9' and platform_machine != 's390x' and sys_platform == 'linux' and extra == 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version < '3.9' and platform_machine != 's390x' and sys_platform == 'linux' and extra == 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version < '3.9' and platform_machine != 's390x' and sys_platform == 'linux' and extra == 'extra-13-lightly-train-rfdetr' and extra != 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version < '3.9' and platform_machine != 's390x' and sys_platform == 'linux' and extra == 'extra-13-lightly-train-rfdetr' and extra != 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version == '3.9.*' and platform_machine != 'aarch64' and sys_platform == 'linux' and extra != 'extra-13-lightly-train-onnx' and extra != 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-rfdetr' and extra == 'group-13-lightly-train-minimal-torch') or (python_full_version == '3.9.*' and platform_machine != 'aarch64' and sys_platform == 'linux' and extra != 'extra-13-lightly-train-onnx' and extra != 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-rfdetr' and extra != 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version < '3.9' and platform_machine != 's390x' and sys_platform == 'linux' and extra != 'extra-13-lightly-train-onnx' and extra != 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-rfdetr' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version < '3.9' and platform_machine != 's390x' and sys_platform == 'linux' and extra != 'extra-13-lightly-train-onnx' and extra != 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-rfdetr' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version != '3.9.*' and platform_machine == 's390x' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version != '3.9.*' and platform_machine == 's390x' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version != '3.9.*' and platform_machine == 's390x' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (platform_machine == 's390x' and sys_platform != 'linux' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (platform_machine == 's390x' and sys_platform != 'linux' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (platform_machine == 'aarch64' and sys_platform == 'linux' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (platform_machine == 'aarch64' and sys_platform == 'linux' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (platform_machine != 's390x' and sys_platform != 'linux' and extra == 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (platform_machine != 's390x' and sys_platform != 'linux' and extra == 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (platform_machine != 's390x' and sys_platform != 'linux' and extra == 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (platform_machine == 'aarch64' and extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (platform_machine == 'aarch64' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (platform_machine == 'aarch64' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (platform_machine == 's390x' and extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (platform_machine == 's390x' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (platform_machine == 's390x' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (platform_machine == 'aarch64' and extra != 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (platform_machine == 's390x' and extra != 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (sys_platform != 'linux' and extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (sys_platform != 'linux' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (sys_platform != 'linux' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (sys_platform == 'darwin' and extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (sys_platform == 'darwin' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (sys_platform == 'darwin' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (sys_platform == 'darwin' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (sys_platform == 'darwin' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (sys_platform == 'darwin' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (sys_platform == 'win32' and extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (sys_platform == 'win32' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (sys_platform == 'win32' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (sys_platform == 'win32' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (sys_platform == 'win32' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (sys_platform == 'win32' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (sys_platform != 'linux' and extra != 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal')" }, ] wheels = [ { url = "https://files.pythonhosted.org/packages/60/bc/7771846d3a0272026c416fbb7e5f4c1f146d6d80704534d0b187dd6f4800/nvidia_cufft_cu12-11.3.3.83-py3-none-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:848ef7224d6305cdb2a4df928759dca7b1201874787083b6e7550dd6765ce69a", size = 193109211, upload-time = "2025-03-07T01:44:56.873Z" }, @@ -32091,9 +32093,9 @@ name = "nvidia-cusolver" version = "12.0.4.66" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "nvidia-cublas", marker = "(python_full_version >= '3.10' and python_full_version < '3.12' and extra == 'group-13-lightly-train-minimal-torch') or (python_full_version >= '3.10' and python_full_version < '3.12' and extra != 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version < '3.10' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version < '3.10' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version < '3.10' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.12' and extra == 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch') or (python_full_version >= '3.12' and extra == 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.12' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.12' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (extra != 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal')" }, - { name = "nvidia-cusparse", marker = "(python_full_version >= '3.10' and python_full_version < '3.12' and extra == 'group-13-lightly-train-minimal-torch') or (python_full_version >= '3.10' and python_full_version < '3.12' and extra != 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version < '3.10' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version < '3.10' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version < '3.10' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.12' and extra == 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch') or (python_full_version >= '3.12' and extra == 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.12' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.12' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (extra != 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal')" }, - { name = "nvidia-nvjitlink", marker = "(python_full_version >= '3.10' and python_full_version < '3.12' and extra == 'group-13-lightly-train-minimal-torch') or (python_full_version >= '3.10' and python_full_version < '3.12' and extra != 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version < '3.10' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version < '3.10' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version < '3.10' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.12' and extra == 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch') or (python_full_version >= '3.12' and extra == 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.12' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.12' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (extra != 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal')" }, + { name = "nvidia-cublas", marker = "(python_full_version >= '3.10' and python_full_version < '3.12' and sys_platform == 'linux' and extra == 'group-13-lightly-train-minimal-torch') or (python_full_version >= '3.10' and python_full_version < '3.12' and sys_platform == 'linux' and extra != 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version < '3.12' and sys_platform != 'linux' and extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version < '3.12' and sys_platform != 'linux' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version < '3.12' and sys_platform != 'linux' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version < '3.12' and sys_platform != 'linux' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version < '3.12' and sys_platform != 'linux' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version < '3.12' and sys_platform != 'linux' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.12' and sys_platform != 'win32' and extra == 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch') or (python_full_version >= '3.12' and sys_platform != 'win32' and extra == 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version < '3.10' and sys_platform == 'linux' and extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version < '3.10' and sys_platform == 'linux' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version < '3.10' and sys_platform == 'linux' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version < '3.10' and sys_platform == 'linux' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version < '3.10' and sys_platform == 'linux' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version < '3.10' and sys_platform == 'linux' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.12' and sys_platform == 'linux' and extra == 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch') or (python_full_version >= '3.12' and sys_platform == 'linux' and extra == 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.10' and extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version >= '3.10' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version >= '3.10' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version >= '3.12' and extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version >= '3.12' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version >= '3.12' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version >= '3.12' and extra == 'extra-13-lightly-train-onnx' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.12' and extra == 'extra-13-lightly-train-onnx' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.12' and extra == 'extra-13-lightly-train-onnx' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.12' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.12' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.12' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.12' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.12' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.12' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.10' and extra != 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.12' and extra != 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.12' and extra != 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.12' and extra != 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (sys_platform == 'win32' and extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (sys_platform == 'win32' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (sys_platform == 'win32' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (sys_platform == 'win32' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (sys_platform == 'win32' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (sys_platform == 'win32' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal')" }, + { name = "nvidia-cusparse", marker = "(python_full_version >= '3.10' and python_full_version < '3.12' and sys_platform == 'linux' and extra == 'group-13-lightly-train-minimal-torch') or (python_full_version >= '3.10' and python_full_version < '3.12' and sys_platform == 'linux' and extra != 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version < '3.12' and sys_platform != 'linux' and extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version < '3.12' and sys_platform != 'linux' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version < '3.12' and sys_platform != 'linux' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version < '3.12' and sys_platform != 'linux' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version < '3.12' and sys_platform != 'linux' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version < '3.12' and sys_platform != 'linux' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.12' and sys_platform != 'win32' and extra == 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch') or (python_full_version >= '3.12' and sys_platform != 'win32' and extra == 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version < '3.10' and sys_platform == 'linux' and extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version < '3.10' and sys_platform == 'linux' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version < '3.10' and sys_platform == 'linux' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version < '3.10' and sys_platform == 'linux' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version < '3.10' and sys_platform == 'linux' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version < '3.10' and sys_platform == 'linux' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.12' and sys_platform == 'linux' and extra == 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch') or (python_full_version >= '3.12' and sys_platform == 'linux' and extra == 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.10' and extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version >= '3.10' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version >= '3.10' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version >= '3.12' and extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version >= '3.12' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version >= '3.12' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version >= '3.12' and extra == 'extra-13-lightly-train-onnx' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.12' and extra == 'extra-13-lightly-train-onnx' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.12' and extra == 'extra-13-lightly-train-onnx' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.12' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.12' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.12' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.12' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.12' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.12' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.10' and extra != 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.12' and extra != 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.12' and extra != 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.12' and extra != 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (sys_platform == 'win32' and extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (sys_platform == 'win32' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (sys_platform == 'win32' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (sys_platform == 'win32' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (sys_platform == 'win32' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (sys_platform == 'win32' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal')" }, + { name = "nvidia-nvjitlink", marker = "(python_full_version >= '3.10' and python_full_version < '3.12' and sys_platform == 'linux' and extra == 'group-13-lightly-train-minimal-torch') or (python_full_version >= '3.10' and python_full_version < '3.12' and sys_platform == 'linux' and extra != 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version < '3.12' and sys_platform != 'linux' and extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version < '3.12' and sys_platform != 'linux' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version < '3.12' and sys_platform != 'linux' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version < '3.12' and sys_platform != 'linux' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version < '3.12' and sys_platform != 'linux' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version < '3.12' and sys_platform != 'linux' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.12' and sys_platform != 'win32' and extra == 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch') or (python_full_version >= '3.12' and sys_platform != 'win32' and extra == 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version < '3.10' and sys_platform == 'linux' and extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version < '3.10' and sys_platform == 'linux' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version < '3.10' and sys_platform == 'linux' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version < '3.10' and sys_platform == 'linux' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version < '3.10' and sys_platform == 'linux' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version < '3.10' and sys_platform == 'linux' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.12' and sys_platform == 'linux' and extra == 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch') or (python_full_version >= '3.12' and sys_platform == 'linux' and extra == 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.10' and extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version >= '3.10' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version >= '3.10' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version >= '3.12' and extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version >= '3.12' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version >= '3.12' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version >= '3.12' and extra == 'extra-13-lightly-train-onnx' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.12' and extra == 'extra-13-lightly-train-onnx' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.12' and extra == 'extra-13-lightly-train-onnx' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.12' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.12' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.12' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.12' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.12' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.12' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.10' and extra != 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.12' and extra != 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.12' and extra != 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.12' and extra != 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (sys_platform == 'win32' and extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (sys_platform == 'win32' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (sys_platform == 'win32' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (sys_platform == 'win32' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (sys_platform == 'win32' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (sys_platform == 'win32' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal')" }, ] wheels = [ { url = "https://files.pythonhosted.org/packages/c8/c3/b30c9e935fc01e3da443ec0116ed1b2a009bb867f5324d3f2d7e533e776b/nvidia_cusolver-12.0.4.66-py3-none-manylinux_2_27_aarch64.whl", hash = "sha256:02c2457eaa9e39de20f880f4bd8820e6a1cfb9f9a34f820eb12a155aa5bc92d2", size = 223467760, upload-time = "2025-09-04T08:33:04.222Z" }, @@ -32106,7 +32108,7 @@ name = "nvidia-cusolver-cu11" version = "11.4.1.48" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "nvidia-cublas-cu11", marker = "(python_full_version < '3.9' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.9' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal')" }, + { name = "nvidia-cublas-cu11", marker = "(python_full_version >= '3.9' and python_full_version < '3.12' and platform_machine == 's390x' and sys_platform == 'linux' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.9' and platform_machine != 'aarch64' and platform_machine != 's390x' and sys_platform == 'linux' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.12' and platform_machine != 's390x' and sys_platform != 'darwin' and sys_platform != 'linux' and sys_platform != 'win32' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version < '3.12' and platform_machine != 's390x' and sys_platform != 'linux' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version < '3.12' and platform_machine != 's390x' and sys_platform != 'linux' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version < '3.12' and platform_machine != 's390x' and sys_platform != 'linux' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.12' and platform_machine != 's390x' and sys_platform == 'darwin' and extra == 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.12' and platform_machine == 'aarch64' and sys_platform == 'linux' and extra == 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version < '3.12' and platform_machine == 'aarch64' and sys_platform == 'linux' and extra != 'extra-13-lightly-train-onnx' and extra != 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-rfdetr' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.12' and platform_machine == 's390x' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version < '3.12' and sys_platform == 'darwin' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version < '3.9' and sys_platform == 'linux' and extra == 'extra-13-lightly-train-onnx' and extra != 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version < '3.9' and sys_platform == 'linux' and extra == 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version < '3.9' and sys_platform == 'linux' and extra == 'extra-13-lightly-train-rfdetr' and extra != 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version < '3.9' and sys_platform == 'linux' and extra != 'extra-13-lightly-train-onnx' and extra != 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-rfdetr' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version < '3.9' and sys_platform == 'linux' and extra != 'extra-13-lightly-train-onnx' and extra != 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-rfdetr' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (platform_machine != 'aarch64' and platform_machine != 's390x' and sys_platform == 'linux' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (platform_machine != 'aarch64' and platform_machine != 's390x' and sys_platform == 'linux' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (platform_machine != 'aarch64' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (platform_machine != 'aarch64' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (platform_machine != 'aarch64' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (platform_machine != 'aarch64' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-onnx' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (platform_machine != 'aarch64' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-onnx' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (platform_machine != 'aarch64' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (platform_machine != 'aarch64' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (platform_machine != 'aarch64' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (platform_machine != 'aarch64' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (platform_machine != 's390x' and sys_platform != 'darwin' and sys_platform != 'linux' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (platform_machine != 's390x' and sys_platform != 'darwin' and sys_platform != 'linux' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (platform_machine == 's390x' and sys_platform != 'linux' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (platform_machine == 's390x' and sys_platform == 'darwin' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (platform_machine == 'aarch64' and sys_platform == 'linux' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (platform_machine == 'aarch64' and sys_platform == 'linux' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (platform_machine == 'aarch64' and sys_platform == 'linux' and extra == 'extra-13-lightly-train-onnx' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (platform_machine == 'aarch64' and sys_platform == 'linux' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (platform_machine == 'aarch64' and sys_platform == 'linux' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (platform_machine == 'aarch64' and sys_platform == 'linux' and extra != 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (platform_machine == 'aarch64' and extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (platform_machine == 'aarch64' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (platform_machine == 'aarch64' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (platform_machine == 's390x' and extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (platform_machine == 's390x' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (platform_machine == 's390x' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (platform_machine == 's390x' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (platform_machine == 's390x' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (platform_machine == 'aarch64' and extra == 'extra-13-lightly-train-onnx' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (platform_machine == 'aarch64' and extra == 'extra-13-lightly-train-onnx' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (platform_machine == 'aarch64' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (platform_machine == 'aarch64' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (platform_machine == 'aarch64' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (platform_machine == 'aarch64' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (sys_platform != 'linux' and extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (sys_platform != 'linux' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (sys_platform != 'linux' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (sys_platform == 'darwin' and extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (sys_platform == 'darwin' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (sys_platform == 'darwin' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (sys_platform == 'darwin' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (sys_platform == 'darwin' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (sys_platform == 'win32' and extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (sys_platform == 'win32' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (sys_platform == 'win32' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (sys_platform == 'win32' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (sys_platform == 'win32' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (sys_platform == 'win32' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (sys_platform != 'linux' and extra == 'extra-13-lightly-train-onnx' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (sys_platform != 'linux' and extra == 'extra-13-lightly-train-onnx' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (sys_platform != 'linux' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (sys_platform != 'linux' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (sys_platform != 'linux' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (sys_platform != 'linux' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (sys_platform == 'darwin' and extra == 'extra-13-lightly-train-onnx' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (sys_platform == 'darwin' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (sys_platform == 'darwin' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (sys_platform == 'darwin' and extra != 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal')" }, ] wheels = [ { url = "https://files.pythonhosted.org/packages/55/ee/939ff0104991dd7bdabb4c9767994c612ba0e1c9a55672a1ddd42f5e5b16/nvidia_cusolver_cu11-11.4.1.48-py3-none-manylinux1_x86_64.whl", hash = "sha256:ca538f545645b7e6629140786d3127fe067b3d5a085bd794cde5bfe877c8926f", size = 128240842, upload-time = "2022-10-03T23:30:24.348Z" }, @@ -32123,9 +32125,9 @@ resolution-markers = [ "python_full_version < '3.9' and sys_platform == 'linux'", ] dependencies = [ - { name = "nvidia-cublas-cu12", version = "12.1.3.1", source = { registry = "https://pypi.org/simple" }, marker = "(python_full_version < '3.9' and sys_platform != 'win32' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version < '3.9' and sys_platform != 'win32' and extra != 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version < '3.9' and extra == 'group-13-lightly-train-minimal-torch') or (python_full_version < '3.9' and extra == 'extra-13-lightly-train-onnx' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version < '3.9' and extra == 'extra-13-lightly-train-onnx' and extra != 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version < '3.9' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version < '3.9' and extra == 'extra-13-lightly-train-onnxruntime' and extra != 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version < '3.9' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version < '3.9' and extra == 'extra-13-lightly-train-rfdetr' and extra != 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version < '3.9' and extra != 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version < '3.9' and extra != 'group-13-lightly-train-pinned-torch-maximal' and extra != 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.9' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (extra == 'extra-13-lightly-train-onnx' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (extra == 'extra-13-lightly-train-onnxruntime' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (extra == 'extra-13-lightly-train-rfdetr' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (extra == 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal')" }, - { name = "nvidia-cusparse-cu12", version = "12.1.0.106", source = { registry = "https://pypi.org/simple" }, marker = "(python_full_version < '3.9' and sys_platform != 'win32' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version < '3.9' and sys_platform != 'win32' and extra != 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version < '3.9' and extra == 'group-13-lightly-train-minimal-torch') or (python_full_version < '3.9' and extra == 'extra-13-lightly-train-onnx' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version < '3.9' and extra == 'extra-13-lightly-train-onnx' and extra != 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version < '3.9' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version < '3.9' and extra == 'extra-13-lightly-train-onnxruntime' and extra != 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version < '3.9' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version < '3.9' and extra == 'extra-13-lightly-train-rfdetr' and extra != 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version < '3.9' and extra != 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version < '3.9' and extra != 'group-13-lightly-train-pinned-torch-maximal' and extra != 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.9' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (extra == 'extra-13-lightly-train-onnx' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (extra == 'extra-13-lightly-train-onnxruntime' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (extra == 'extra-13-lightly-train-rfdetr' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (extra == 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal')" }, - { name = "nvidia-nvjitlink-cu12", marker = "(python_full_version < '3.9' and sys_platform != 'win32' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version < '3.9' and sys_platform != 'win32' and extra != 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version < '3.9' and extra == 'group-13-lightly-train-minimal-torch') or (python_full_version < '3.9' and extra == 'extra-13-lightly-train-onnx' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version < '3.9' and extra == 'extra-13-lightly-train-onnx' and extra != 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version < '3.9' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version < '3.9' and extra == 'extra-13-lightly-train-onnxruntime' and extra != 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version < '3.9' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version < '3.9' and extra == 'extra-13-lightly-train-rfdetr' and extra != 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version < '3.9' and extra != 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version < '3.9' and extra != 'group-13-lightly-train-pinned-torch-maximal' and extra != 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.9' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (extra == 'extra-13-lightly-train-onnx' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (extra == 'extra-13-lightly-train-onnxruntime' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (extra == 'extra-13-lightly-train-rfdetr' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (extra == 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal')" }, + { name = "nvidia-cublas-cu12", version = "12.1.3.1", source = { registry = "https://pypi.org/simple" }, marker = "(python_full_version < '3.9' and sys_platform == 'linux' and extra == 'group-13-lightly-train-minimal-torch') or (python_full_version < '3.9' and sys_platform == 'linux' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version < '3.9' and sys_platform == 'linux' and extra != 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.9' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.9' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.9' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (sys_platform != 'linux' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (sys_platform != 'linux' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (sys_platform != 'linux' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients')" }, + { name = "nvidia-cusparse-cu12", version = "12.1.0.106", source = { registry = "https://pypi.org/simple" }, marker = "(python_full_version < '3.9' and sys_platform == 'linux' and extra == 'group-13-lightly-train-minimal-torch') or (python_full_version < '3.9' and sys_platform == 'linux' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version < '3.9' and sys_platform == 'linux' and extra != 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.9' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.9' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.9' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (sys_platform != 'linux' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (sys_platform != 'linux' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (sys_platform != 'linux' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients')" }, + { name = "nvidia-nvjitlink-cu12", marker = "(python_full_version < '3.9' and sys_platform == 'linux' and extra == 'group-13-lightly-train-minimal-torch') or (python_full_version < '3.9' and sys_platform == 'linux' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version < '3.9' and sys_platform == 'linux' and extra != 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.9' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.9' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.9' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (sys_platform != 'linux' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (sys_platform != 'linux' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (sys_platform != 'linux' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients')" }, ] wheels = [ { url = "https://files.pythonhosted.org/packages/bc/1d/8de1e5c67099015c834315e333911273a8c6aaba78923dd1d1e25fc5f217/nvidia_cusolver_cu12-11.4.5.107-py3-none-manylinux1_x86_64.whl", hash = "sha256:8a7ec542f0412294b15072fa7dab71d31334014a69f953004ea7a118206fe0dd", size = 124161928, upload-time = "2023-04-19T15:51:25.781Z" }, @@ -32142,9 +32144,9 @@ resolution-markers = [ "(python_full_version == '3.12.*' and platform_machine != 'aarch64' and platform_machine != 's390x' and sys_platform == 'linux') or (python_full_version == '3.12.*' and platform_machine != 's390x' and sys_platform != 'darwin' and sys_platform != 'linux' and sys_platform != 'win32')", ] dependencies = [ - { name = "nvidia-cublas-cu12", version = "12.8.4.1", source = { registry = "https://pypi.org/simple" }, marker = "(python_full_version >= '3.10' and python_full_version < '3.12' and platform_machine != 's390x' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.10' and python_full_version < '3.12' and platform_machine != 's390x' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.10' and python_full_version < '3.12' and platform_machine != 's390x' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version < '3.9' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version < '3.9' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version < '3.9' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version < '3.9' and platform_machine != 's390x' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version < '3.9' and platform_machine != 's390x' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version < '3.9' and platform_machine != 's390x' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.10' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version >= '3.10' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version >= '3.10' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version >= '3.12' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version >= '3.12' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-onnx' and extra == 'group-13-lightly-train-minimal-torch') or (python_full_version >= '3.12' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-onnx' and extra != 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.12' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version >= '3.12' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'group-13-lightly-train-minimal-torch') or (python_full_version >= '3.12' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-onnxruntime' and extra != 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.12' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version >= '3.12' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'group-13-lightly-train-minimal-torch') or (python_full_version >= '3.12' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-rfdetr' and extra != 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.12' and platform_machine != 's390x' and extra != 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch') or (python_full_version >= '3.12' and platform_machine != 's390x' and extra != 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.10' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-onnx' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.10' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-onnx' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.10' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-onnx' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.10' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.10' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.10' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.10' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.10' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.10' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.12' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-onnx' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.12' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.12' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.12' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.12' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.12' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.12' and platform_machine != 's390x' and extra != 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version == '3.9.*' and extra == 'group-13-lightly-train-minimal-torch') or (python_full_version == '3.9.*' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version == '3.9.*' and extra != 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version == '3.9.*' and extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version == '3.9.*' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version == '3.9.*' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (platform_machine == 's390x' and extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (platform_machine == 's390x' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (platform_machine == 's390x' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (platform_machine == 's390x' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (platform_machine == 's390x' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (platform_machine == 's390x' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal')" }, - { name = "nvidia-cusparse-cu12", version = "12.5.8.93", source = { registry = "https://pypi.org/simple" }, marker = "(python_full_version >= '3.10' and python_full_version < '3.12' and platform_machine != 's390x' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.10' and python_full_version < '3.12' and platform_machine != 's390x' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.10' and python_full_version < '3.12' and platform_machine != 's390x' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version < '3.9' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version < '3.9' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version < '3.9' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version < '3.9' and platform_machine != 's390x' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version < '3.9' and platform_machine != 's390x' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version < '3.9' and platform_machine != 's390x' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.10' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version >= '3.10' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version >= '3.10' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version >= '3.12' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version >= '3.12' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-onnx' and extra == 'group-13-lightly-train-minimal-torch') or (python_full_version >= '3.12' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-onnx' and extra != 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.12' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version >= '3.12' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'group-13-lightly-train-minimal-torch') or (python_full_version >= '3.12' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-onnxruntime' and extra != 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.12' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version >= '3.12' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'group-13-lightly-train-minimal-torch') or (python_full_version >= '3.12' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-rfdetr' and extra != 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.12' and platform_machine != 's390x' and extra != 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch') or (python_full_version >= '3.12' and platform_machine != 's390x' and extra != 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.10' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-onnx' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.10' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-onnx' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.10' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-onnx' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.10' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.10' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.10' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.10' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.10' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.10' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.12' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-onnx' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.12' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.12' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.12' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.12' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.12' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.12' and platform_machine != 's390x' and extra != 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version == '3.9.*' and extra == 'group-13-lightly-train-minimal-torch') or (python_full_version == '3.9.*' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version == '3.9.*' and extra != 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version == '3.9.*' and extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version == '3.9.*' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version == '3.9.*' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (platform_machine == 's390x' and extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (platform_machine == 's390x' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (platform_machine == 's390x' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (platform_machine == 's390x' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (platform_machine == 's390x' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (platform_machine == 's390x' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal')" }, - { name = "nvidia-nvjitlink-cu12", marker = "(python_full_version >= '3.10' and python_full_version < '3.12' and platform_machine != 's390x' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.10' and python_full_version < '3.12' and platform_machine != 's390x' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.10' and python_full_version < '3.12' and platform_machine != 's390x' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version < '3.9' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version < '3.9' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version < '3.9' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version < '3.9' and platform_machine != 's390x' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version < '3.9' and platform_machine != 's390x' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version < '3.9' and platform_machine != 's390x' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.10' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version >= '3.10' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version >= '3.10' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version >= '3.12' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version >= '3.12' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-onnx' and extra == 'group-13-lightly-train-minimal-torch') or (python_full_version >= '3.12' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-onnx' and extra != 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.12' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version >= '3.12' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'group-13-lightly-train-minimal-torch') or (python_full_version >= '3.12' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-onnxruntime' and extra != 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.12' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version >= '3.12' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'group-13-lightly-train-minimal-torch') or (python_full_version >= '3.12' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-rfdetr' and extra != 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.12' and platform_machine != 's390x' and extra != 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch') or (python_full_version >= '3.12' and platform_machine != 's390x' and extra != 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.10' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-onnx' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.10' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-onnx' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.10' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-onnx' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.10' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.10' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.10' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.10' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.10' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.10' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.12' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-onnx' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.12' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.12' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.12' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.12' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.12' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.12' and platform_machine != 's390x' and extra != 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version == '3.9.*' and extra == 'group-13-lightly-train-minimal-torch') or (python_full_version == '3.9.*' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version == '3.9.*' and extra != 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version == '3.9.*' and extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version == '3.9.*' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version == '3.9.*' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (platform_machine == 's390x' and extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (platform_machine == 's390x' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (platform_machine == 's390x' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (platform_machine == 's390x' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (platform_machine == 's390x' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (platform_machine == 's390x' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal')" }, + { name = "nvidia-cublas-cu12", version = "12.8.4.1", source = { registry = "https://pypi.org/simple" }, marker = "(python_full_version >= '3.10' and python_full_version < '3.12' and platform_machine != 'aarch64' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version >= '3.10' and python_full_version < '3.12' and platform_machine != 'aarch64' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version >= '3.10' and python_full_version < '3.12' and platform_machine != 'aarch64' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version >= '3.10' and python_full_version < '3.12' and platform_machine != 'aarch64' and platform_machine != 's390x' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.10' and python_full_version < '3.12' and platform_machine != 'aarch64' and platform_machine != 's390x' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.10' and python_full_version < '3.12' and platform_machine != 'aarch64' and platform_machine != 's390x' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.12' and platform_machine != 'aarch64' and platform_machine != 's390x' and sys_platform == 'linux' and extra == 'extra-13-lightly-train-onnx' and extra == 'group-13-lightly-train-minimal-torch') or (python_full_version >= '3.12' and platform_machine != 'aarch64' and platform_machine != 's390x' and sys_platform == 'linux' and extra == 'extra-13-lightly-train-onnx' and extra != 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.12' and platform_machine != 'aarch64' and platform_machine != 's390x' and sys_platform == 'linux' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'group-13-lightly-train-minimal-torch') or (python_full_version >= '3.12' and platform_machine != 'aarch64' and platform_machine != 's390x' and sys_platform == 'linux' and extra == 'extra-13-lightly-train-onnxruntime' and extra != 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.12' and platform_machine != 'aarch64' and platform_machine != 's390x' and sys_platform == 'linux' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'group-13-lightly-train-minimal-torch') or (python_full_version >= '3.12' and platform_machine != 'aarch64' and platform_machine != 's390x' and sys_platform == 'linux' and extra == 'extra-13-lightly-train-rfdetr' and extra != 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.12' and platform_machine != 'aarch64' and platform_machine != 's390x' and sys_platform == 'linux' and extra != 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch') or (python_full_version >= '3.12' and platform_machine != 'aarch64' and platform_machine != 's390x' and sys_platform == 'linux' and extra != 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version < '3.9' and platform_machine != 'aarch64' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version < '3.9' and platform_machine != 'aarch64' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version < '3.9' and platform_machine != 'aarch64' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version == '3.9.*' and platform_machine != 'aarch64' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version == '3.9.*' and platform_machine != 'aarch64' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version == '3.9.*' and platform_machine != 'aarch64' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version >= '3.12' and platform_machine != 'aarch64' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version >= '3.12' and platform_machine != 'aarch64' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version >= '3.12' and platform_machine != 'aarch64' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version < '3.9' and platform_machine != 'aarch64' and platform_machine != 's390x' and extra != 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version == '3.9.*' and platform_machine != 'aarch64' and platform_machine != 's390x' and extra != 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.12' and platform_machine != 'aarch64' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.12' and platform_machine != 'aarch64' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.12' and platform_machine != 'aarch64' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.12' and platform_machine != 'aarch64' and platform_machine != 's390x' and extra != 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.12' and platform_machine != 's390x' and sys_platform != 'darwin' and sys_platform != 'linux' and sys_platform != 'win32' and extra == 'extra-13-lightly-train-onnx' and extra == 'group-13-lightly-train-minimal-torch') or (python_full_version >= '3.12' and platform_machine != 's390x' and sys_platform != 'darwin' and sys_platform != 'linux' and sys_platform != 'win32' and extra == 'extra-13-lightly-train-onnx' and extra != 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.12' and platform_machine != 's390x' and sys_platform != 'darwin' and sys_platform != 'linux' and sys_platform != 'win32' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'group-13-lightly-train-minimal-torch') or (python_full_version >= '3.12' and platform_machine != 's390x' and sys_platform != 'darwin' and sys_platform != 'linux' and sys_platform != 'win32' and extra == 'extra-13-lightly-train-onnxruntime' and extra != 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.12' and platform_machine != 's390x' and sys_platform != 'darwin' and sys_platform != 'linux' and sys_platform != 'win32' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'group-13-lightly-train-minimal-torch') or (python_full_version >= '3.12' and platform_machine != 's390x' and sys_platform != 'darwin' and sys_platform != 'linux' and sys_platform != 'win32' and extra == 'extra-13-lightly-train-rfdetr' and extra != 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.12' and platform_machine != 's390x' and sys_platform != 'darwin' and sys_platform != 'linux' and sys_platform != 'win32' and extra != 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch') or (python_full_version >= '3.12' and platform_machine != 's390x' and sys_platform != 'darwin' and sys_platform != 'linux' and sys_platform != 'win32' and extra != 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version == '3.9.*' and platform_machine == 's390x' and sys_platform == 'linux' and extra == 'group-13-lightly-train-minimal-torch') or (python_full_version == '3.9.*' and platform_machine == 's390x' and sys_platform == 'linux' and extra != 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version < '3.12' and platform_machine != 's390x' and sys_platform != 'linux' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version < '3.12' and platform_machine != 's390x' and sys_platform != 'linux' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version < '3.12' and platform_machine != 's390x' and sys_platform != 'linux' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version == '3.9.*' and platform_machine != 'aarch64' and sys_platform == 'linux' and extra == 'extra-13-lightly-train-onnx' and extra != 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch') or (python_full_version == '3.9.*' and platform_machine != 'aarch64' and sys_platform == 'linux' and extra == 'extra-13-lightly-train-onnx' and extra != 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version == '3.9.*' and platform_machine != 'aarch64' and sys_platform == 'linux' and extra == 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch') or (python_full_version == '3.9.*' and platform_machine != 'aarch64' and sys_platform == 'linux' and extra == 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version == '3.9.*' and platform_machine != 'aarch64' and sys_platform == 'linux' and extra == 'extra-13-lightly-train-rfdetr' and extra != 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch') or (python_full_version == '3.9.*' and platform_machine != 'aarch64' and sys_platform == 'linux' and extra == 'extra-13-lightly-train-rfdetr' and extra != 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version < '3.9' and platform_machine != 's390x' and sys_platform == 'linux' and extra == 'extra-13-lightly-train-onnx' and extra != 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version < '3.9' and platform_machine != 's390x' and sys_platform == 'linux' and extra == 'extra-13-lightly-train-onnx' and extra != 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version < '3.9' and platform_machine != 's390x' and sys_platform == 'linux' and extra == 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version < '3.9' and platform_machine != 's390x' and sys_platform == 'linux' and extra == 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version < '3.9' and platform_machine != 's390x' and sys_platform == 'linux' and extra == 'extra-13-lightly-train-rfdetr' and extra != 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version < '3.9' and platform_machine != 's390x' and sys_platform == 'linux' and extra == 'extra-13-lightly-train-rfdetr' and extra != 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version == '3.9.*' and platform_machine != 'aarch64' and sys_platform == 'linux' and extra != 'extra-13-lightly-train-onnx' and extra != 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-rfdetr' and extra == 'group-13-lightly-train-minimal-torch') or (python_full_version == '3.9.*' and platform_machine != 'aarch64' and sys_platform == 'linux' and extra != 'extra-13-lightly-train-onnx' and extra != 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-rfdetr' and extra != 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version < '3.9' and platform_machine != 's390x' and sys_platform == 'linux' and extra != 'extra-13-lightly-train-onnx' and extra != 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-rfdetr' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version < '3.9' and platform_machine != 's390x' and sys_platform == 'linux' and extra != 'extra-13-lightly-train-onnx' and extra != 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-rfdetr' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version != '3.9.*' and platform_machine == 's390x' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version != '3.9.*' and platform_machine == 's390x' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version != '3.9.*' and platform_machine == 's390x' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (platform_machine == 's390x' and sys_platform != 'linux' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (platform_machine == 's390x' and sys_platform != 'linux' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (platform_machine == 'aarch64' and sys_platform == 'linux' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (platform_machine == 'aarch64' and sys_platform == 'linux' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (platform_machine != 's390x' and sys_platform != 'linux' and extra == 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (platform_machine != 's390x' and sys_platform != 'linux' and extra == 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (platform_machine != 's390x' and sys_platform != 'linux' and extra == 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (platform_machine == 'aarch64' and extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (platform_machine == 'aarch64' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (platform_machine == 'aarch64' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (platform_machine == 's390x' and extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (platform_machine == 's390x' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (platform_machine == 's390x' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (platform_machine == 'aarch64' and extra != 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (platform_machine == 's390x' and extra != 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (sys_platform != 'linux' and extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (sys_platform != 'linux' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (sys_platform != 'linux' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (sys_platform == 'darwin' and extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (sys_platform == 'darwin' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (sys_platform == 'darwin' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (sys_platform == 'darwin' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (sys_platform == 'darwin' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (sys_platform == 'darwin' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (sys_platform == 'win32' and extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (sys_platform == 'win32' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (sys_platform == 'win32' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (sys_platform == 'win32' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (sys_platform == 'win32' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (sys_platform == 'win32' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (sys_platform != 'linux' and extra != 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal')" }, + { name = "nvidia-cusparse-cu12", version = "12.5.8.93", source = { registry = "https://pypi.org/simple" }, marker = "(python_full_version >= '3.10' and python_full_version < '3.12' and platform_machine != 'aarch64' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version >= '3.10' and python_full_version < '3.12' and platform_machine != 'aarch64' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version >= '3.10' and python_full_version < '3.12' and platform_machine != 'aarch64' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version >= '3.10' and python_full_version < '3.12' and platform_machine != 'aarch64' and platform_machine != 's390x' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.10' and python_full_version < '3.12' and platform_machine != 'aarch64' and platform_machine != 's390x' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.10' and python_full_version < '3.12' and platform_machine != 'aarch64' and platform_machine != 's390x' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.12' and platform_machine != 'aarch64' and platform_machine != 's390x' and sys_platform == 'linux' and extra == 'extra-13-lightly-train-onnx' and extra == 'group-13-lightly-train-minimal-torch') or (python_full_version >= '3.12' and platform_machine != 'aarch64' and platform_machine != 's390x' and sys_platform == 'linux' and extra == 'extra-13-lightly-train-onnx' and extra != 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.12' and platform_machine != 'aarch64' and platform_machine != 's390x' and sys_platform == 'linux' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'group-13-lightly-train-minimal-torch') or (python_full_version >= '3.12' and platform_machine != 'aarch64' and platform_machine != 's390x' and sys_platform == 'linux' and extra == 'extra-13-lightly-train-onnxruntime' and extra != 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.12' and platform_machine != 'aarch64' and platform_machine != 's390x' and sys_platform == 'linux' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'group-13-lightly-train-minimal-torch') or (python_full_version >= '3.12' and platform_machine != 'aarch64' and platform_machine != 's390x' and sys_platform == 'linux' and extra == 'extra-13-lightly-train-rfdetr' and extra != 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.12' and platform_machine != 'aarch64' and platform_machine != 's390x' and sys_platform == 'linux' and extra != 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch') or (python_full_version >= '3.12' and platform_machine != 'aarch64' and platform_machine != 's390x' and sys_platform == 'linux' and extra != 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version < '3.9' and platform_machine != 'aarch64' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version < '3.9' and platform_machine != 'aarch64' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version < '3.9' and platform_machine != 'aarch64' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version == '3.9.*' and platform_machine != 'aarch64' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version == '3.9.*' and platform_machine != 'aarch64' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version == '3.9.*' and platform_machine != 'aarch64' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version >= '3.12' and platform_machine != 'aarch64' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version >= '3.12' and platform_machine != 'aarch64' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version >= '3.12' and platform_machine != 'aarch64' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version < '3.9' and platform_machine != 'aarch64' and platform_machine != 's390x' and extra != 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version == '3.9.*' and platform_machine != 'aarch64' and platform_machine != 's390x' and extra != 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.12' and platform_machine != 'aarch64' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.12' and platform_machine != 'aarch64' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.12' and platform_machine != 'aarch64' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.12' and platform_machine != 'aarch64' and platform_machine != 's390x' and extra != 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.12' and platform_machine != 's390x' and sys_platform != 'darwin' and sys_platform != 'linux' and sys_platform != 'win32' and extra == 'extra-13-lightly-train-onnx' and extra == 'group-13-lightly-train-minimal-torch') or (python_full_version >= '3.12' and platform_machine != 's390x' and sys_platform != 'darwin' and sys_platform != 'linux' and sys_platform != 'win32' and extra == 'extra-13-lightly-train-onnx' and extra != 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.12' and platform_machine != 's390x' and sys_platform != 'darwin' and sys_platform != 'linux' and sys_platform != 'win32' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'group-13-lightly-train-minimal-torch') or (python_full_version >= '3.12' and platform_machine != 's390x' and sys_platform != 'darwin' and sys_platform != 'linux' and sys_platform != 'win32' and extra == 'extra-13-lightly-train-onnxruntime' and extra != 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.12' and platform_machine != 's390x' and sys_platform != 'darwin' and sys_platform != 'linux' and sys_platform != 'win32' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'group-13-lightly-train-minimal-torch') or (python_full_version >= '3.12' and platform_machine != 's390x' and sys_platform != 'darwin' and sys_platform != 'linux' and sys_platform != 'win32' and extra == 'extra-13-lightly-train-rfdetr' and extra != 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.12' and platform_machine != 's390x' and sys_platform != 'darwin' and sys_platform != 'linux' and sys_platform != 'win32' and extra != 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch') or (python_full_version >= '3.12' and platform_machine != 's390x' and sys_platform != 'darwin' and sys_platform != 'linux' and sys_platform != 'win32' and extra != 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version == '3.9.*' and platform_machine == 's390x' and sys_platform == 'linux' and extra == 'group-13-lightly-train-minimal-torch') or (python_full_version == '3.9.*' and platform_machine == 's390x' and sys_platform == 'linux' and extra != 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version < '3.12' and platform_machine != 's390x' and sys_platform != 'linux' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version < '3.12' and platform_machine != 's390x' and sys_platform != 'linux' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version < '3.12' and platform_machine != 's390x' and sys_platform != 'linux' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version == '3.9.*' and platform_machine != 'aarch64' and sys_platform == 'linux' and extra == 'extra-13-lightly-train-onnx' and extra != 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch') or (python_full_version == '3.9.*' and platform_machine != 'aarch64' and sys_platform == 'linux' and extra == 'extra-13-lightly-train-onnx' and extra != 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version == '3.9.*' and platform_machine != 'aarch64' and sys_platform == 'linux' and extra == 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch') or (python_full_version == '3.9.*' and platform_machine != 'aarch64' and sys_platform == 'linux' and extra == 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version == '3.9.*' and platform_machine != 'aarch64' and sys_platform == 'linux' and extra == 'extra-13-lightly-train-rfdetr' and extra != 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch') or (python_full_version == '3.9.*' and platform_machine != 'aarch64' and sys_platform == 'linux' and extra == 'extra-13-lightly-train-rfdetr' and extra != 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version < '3.9' and platform_machine != 's390x' and sys_platform == 'linux' and extra == 'extra-13-lightly-train-onnx' and extra != 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version < '3.9' and platform_machine != 's390x' and sys_platform == 'linux' and extra == 'extra-13-lightly-train-onnx' and extra != 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version < '3.9' and platform_machine != 's390x' and sys_platform == 'linux' and extra == 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version < '3.9' and platform_machine != 's390x' and sys_platform == 'linux' and extra == 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version < '3.9' and platform_machine != 's390x' and sys_platform == 'linux' and extra == 'extra-13-lightly-train-rfdetr' and extra != 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version < '3.9' and platform_machine != 's390x' and sys_platform == 'linux' and extra == 'extra-13-lightly-train-rfdetr' and extra != 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version == '3.9.*' and platform_machine != 'aarch64' and sys_platform == 'linux' and extra != 'extra-13-lightly-train-onnx' and extra != 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-rfdetr' and extra == 'group-13-lightly-train-minimal-torch') or (python_full_version == '3.9.*' and platform_machine != 'aarch64' and sys_platform == 'linux' and extra != 'extra-13-lightly-train-onnx' and extra != 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-rfdetr' and extra != 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version < '3.9' and platform_machine != 's390x' and sys_platform == 'linux' and extra != 'extra-13-lightly-train-onnx' and extra != 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-rfdetr' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version < '3.9' and platform_machine != 's390x' and sys_platform == 'linux' and extra != 'extra-13-lightly-train-onnx' and extra != 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-rfdetr' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version != '3.9.*' and platform_machine == 's390x' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version != '3.9.*' and platform_machine == 's390x' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version != '3.9.*' and platform_machine == 's390x' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (platform_machine == 's390x' and sys_platform != 'linux' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (platform_machine == 's390x' and sys_platform != 'linux' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (platform_machine == 'aarch64' and sys_platform == 'linux' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (platform_machine == 'aarch64' and sys_platform == 'linux' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (platform_machine != 's390x' and sys_platform != 'linux' and extra == 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (platform_machine != 's390x' and sys_platform != 'linux' and extra == 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (platform_machine != 's390x' and sys_platform != 'linux' and extra == 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (platform_machine == 'aarch64' and extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (platform_machine == 'aarch64' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (platform_machine == 'aarch64' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (platform_machine == 's390x' and extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (platform_machine == 's390x' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (platform_machine == 's390x' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (platform_machine == 'aarch64' and extra != 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (platform_machine == 's390x' and extra != 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (sys_platform != 'linux' and extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (sys_platform != 'linux' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (sys_platform != 'linux' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (sys_platform == 'darwin' and extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (sys_platform == 'darwin' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (sys_platform == 'darwin' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (sys_platform == 'darwin' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (sys_platform == 'darwin' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (sys_platform == 'darwin' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (sys_platform == 'win32' and extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (sys_platform == 'win32' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (sys_platform == 'win32' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (sys_platform == 'win32' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (sys_platform == 'win32' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (sys_platform == 'win32' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (sys_platform != 'linux' and extra != 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal')" }, + { name = "nvidia-nvjitlink-cu12", marker = "(python_full_version >= '3.10' and python_full_version < '3.12' and platform_machine != 'aarch64' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version >= '3.10' and python_full_version < '3.12' and platform_machine != 'aarch64' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version >= '3.10' and python_full_version < '3.12' and platform_machine != 'aarch64' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version >= '3.10' and python_full_version < '3.12' and platform_machine != 'aarch64' and platform_machine != 's390x' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.10' and python_full_version < '3.12' and platform_machine != 'aarch64' and platform_machine != 's390x' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.10' and python_full_version < '3.12' and platform_machine != 'aarch64' and platform_machine != 's390x' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.12' and platform_machine != 'aarch64' and platform_machine != 's390x' and sys_platform == 'linux' and extra == 'extra-13-lightly-train-onnx' and extra == 'group-13-lightly-train-minimal-torch') or (python_full_version >= '3.12' and platform_machine != 'aarch64' and platform_machine != 's390x' and sys_platform == 'linux' and extra == 'extra-13-lightly-train-onnx' and extra != 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.12' and platform_machine != 'aarch64' and platform_machine != 's390x' and sys_platform == 'linux' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'group-13-lightly-train-minimal-torch') or (python_full_version >= '3.12' and platform_machine != 'aarch64' and platform_machine != 's390x' and sys_platform == 'linux' and extra == 'extra-13-lightly-train-onnxruntime' and extra != 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.12' and platform_machine != 'aarch64' and platform_machine != 's390x' and sys_platform == 'linux' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'group-13-lightly-train-minimal-torch') or (python_full_version >= '3.12' and platform_machine != 'aarch64' and platform_machine != 's390x' and sys_platform == 'linux' and extra == 'extra-13-lightly-train-rfdetr' and extra != 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.12' and platform_machine != 'aarch64' and platform_machine != 's390x' and sys_platform == 'linux' and extra != 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch') or (python_full_version >= '3.12' and platform_machine != 'aarch64' and platform_machine != 's390x' and sys_platform == 'linux' and extra != 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version < '3.9' and platform_machine != 'aarch64' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version < '3.9' and platform_machine != 'aarch64' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version < '3.9' and platform_machine != 'aarch64' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version == '3.9.*' and platform_machine != 'aarch64' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version == '3.9.*' and platform_machine != 'aarch64' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version == '3.9.*' and platform_machine != 'aarch64' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version >= '3.12' and platform_machine != 'aarch64' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version >= '3.12' and platform_machine != 'aarch64' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version >= '3.12' and platform_machine != 'aarch64' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version < '3.9' and platform_machine != 'aarch64' and platform_machine != 's390x' and extra != 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version == '3.9.*' and platform_machine != 'aarch64' and platform_machine != 's390x' and extra != 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.12' and platform_machine != 'aarch64' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.12' and platform_machine != 'aarch64' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.12' and platform_machine != 'aarch64' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.12' and platform_machine != 'aarch64' and platform_machine != 's390x' and extra != 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.12' and platform_machine != 's390x' and sys_platform != 'darwin' and sys_platform != 'linux' and sys_platform != 'win32' and extra == 'extra-13-lightly-train-onnx' and extra == 'group-13-lightly-train-minimal-torch') or (python_full_version >= '3.12' and platform_machine != 's390x' and sys_platform != 'darwin' and sys_platform != 'linux' and sys_platform != 'win32' and extra == 'extra-13-lightly-train-onnx' and extra != 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.12' and platform_machine != 's390x' and sys_platform != 'darwin' and sys_platform != 'linux' and sys_platform != 'win32' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'group-13-lightly-train-minimal-torch') or (python_full_version >= '3.12' and platform_machine != 's390x' and sys_platform != 'darwin' and sys_platform != 'linux' and sys_platform != 'win32' and extra == 'extra-13-lightly-train-onnxruntime' and extra != 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.12' and platform_machine != 's390x' and sys_platform != 'darwin' and sys_platform != 'linux' and sys_platform != 'win32' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'group-13-lightly-train-minimal-torch') or (python_full_version >= '3.12' and platform_machine != 's390x' and sys_platform != 'darwin' and sys_platform != 'linux' and sys_platform != 'win32' and extra == 'extra-13-lightly-train-rfdetr' and extra != 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.12' and platform_machine != 's390x' and sys_platform != 'darwin' and sys_platform != 'linux' and sys_platform != 'win32' and extra != 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch') or (python_full_version >= '3.12' and platform_machine != 's390x' and sys_platform != 'darwin' and sys_platform != 'linux' and sys_platform != 'win32' and extra != 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version == '3.9.*' and platform_machine == 's390x' and sys_platform == 'linux' and extra == 'group-13-lightly-train-minimal-torch') or (python_full_version == '3.9.*' and platform_machine == 's390x' and sys_platform == 'linux' and extra != 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version < '3.12' and platform_machine != 's390x' and sys_platform != 'linux' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version < '3.12' and platform_machine != 's390x' and sys_platform != 'linux' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version < '3.12' and platform_machine != 's390x' and sys_platform != 'linux' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version == '3.9.*' and platform_machine != 'aarch64' and sys_platform == 'linux' and extra == 'extra-13-lightly-train-onnx' and extra != 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch') or (python_full_version == '3.9.*' and platform_machine != 'aarch64' and sys_platform == 'linux' and extra == 'extra-13-lightly-train-onnx' and extra != 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version == '3.9.*' and platform_machine != 'aarch64' and sys_platform == 'linux' and extra == 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch') or (python_full_version == '3.9.*' and platform_machine != 'aarch64' and sys_platform == 'linux' and extra == 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version == '3.9.*' and platform_machine != 'aarch64' and sys_platform == 'linux' and extra == 'extra-13-lightly-train-rfdetr' and extra != 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch') or (python_full_version == '3.9.*' and platform_machine != 'aarch64' and sys_platform == 'linux' and extra == 'extra-13-lightly-train-rfdetr' and extra != 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version < '3.9' and platform_machine != 's390x' and sys_platform == 'linux' and extra == 'extra-13-lightly-train-onnx' and extra != 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version < '3.9' and platform_machine != 's390x' and sys_platform == 'linux' and extra == 'extra-13-lightly-train-onnx' and extra != 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version < '3.9' and platform_machine != 's390x' and sys_platform == 'linux' and extra == 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version < '3.9' and platform_machine != 's390x' and sys_platform == 'linux' and extra == 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version < '3.9' and platform_machine != 's390x' and sys_platform == 'linux' and extra == 'extra-13-lightly-train-rfdetr' and extra != 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version < '3.9' and platform_machine != 's390x' and sys_platform == 'linux' and extra == 'extra-13-lightly-train-rfdetr' and extra != 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version == '3.9.*' and platform_machine != 'aarch64' and sys_platform == 'linux' and extra != 'extra-13-lightly-train-onnx' and extra != 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-rfdetr' and extra == 'group-13-lightly-train-minimal-torch') or (python_full_version == '3.9.*' and platform_machine != 'aarch64' and sys_platform == 'linux' and extra != 'extra-13-lightly-train-onnx' and extra != 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-rfdetr' and extra != 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version < '3.9' and platform_machine != 's390x' and sys_platform == 'linux' and extra != 'extra-13-lightly-train-onnx' and extra != 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-rfdetr' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version < '3.9' and platform_machine != 's390x' and sys_platform == 'linux' and extra != 'extra-13-lightly-train-onnx' and extra != 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-rfdetr' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version != '3.9.*' and platform_machine == 's390x' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version != '3.9.*' and platform_machine == 's390x' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version != '3.9.*' and platform_machine == 's390x' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (platform_machine == 's390x' and sys_platform != 'linux' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (platform_machine == 's390x' and sys_platform != 'linux' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (platform_machine == 'aarch64' and sys_platform == 'linux' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (platform_machine == 'aarch64' and sys_platform == 'linux' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (platform_machine != 's390x' and sys_platform != 'linux' and extra == 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (platform_machine != 's390x' and sys_platform != 'linux' and extra == 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (platform_machine != 's390x' and sys_platform != 'linux' and extra == 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (platform_machine == 'aarch64' and extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (platform_machine == 'aarch64' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (platform_machine == 'aarch64' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (platform_machine == 's390x' and extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (platform_machine == 's390x' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (platform_machine == 's390x' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (platform_machine == 'aarch64' and extra != 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (platform_machine == 's390x' and extra != 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (sys_platform != 'linux' and extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (sys_platform != 'linux' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (sys_platform != 'linux' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (sys_platform == 'darwin' and extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (sys_platform == 'darwin' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (sys_platform == 'darwin' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (sys_platform == 'darwin' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (sys_platform == 'darwin' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (sys_platform == 'darwin' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (sys_platform == 'win32' and extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (sys_platform == 'win32' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (sys_platform == 'win32' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (sys_platform == 'win32' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (sys_platform == 'win32' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (sys_platform == 'win32' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (sys_platform != 'linux' and extra != 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal')" }, ] wheels = [ { url = "https://files.pythonhosted.org/packages/c8/32/f7cd6ce8a7690544d084ea21c26e910a97e077c9b7f07bf5de623ee19981/nvidia_cusolver_cu12-11.7.3.90-py3-none-manylinux_2_27_aarch64.whl", hash = "sha256:db9ed69dbef9715071232caa9b69c52ac7de3a95773c2db65bdba85916e4e5c0", size = 267229841, upload-time = "2025-03-07T01:46:54.356Z" }, @@ -32157,7 +32159,7 @@ name = "nvidia-cusparse" version = "12.6.3.3" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "nvidia-nvjitlink", marker = "(python_full_version >= '3.10' and python_full_version < '3.12' and extra == 'group-13-lightly-train-minimal-torch') or (python_full_version >= '3.10' and python_full_version < '3.12' and extra != 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version < '3.10' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version < '3.10' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version < '3.10' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.12' and extra == 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch') or (python_full_version >= '3.12' and extra == 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.12' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.12' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (extra != 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal')" }, + { name = "nvidia-nvjitlink", marker = "(python_full_version >= '3.10' and python_full_version < '3.12' and sys_platform == 'linux' and extra == 'group-13-lightly-train-minimal-torch') or (python_full_version >= '3.10' and python_full_version < '3.12' and sys_platform == 'linux' and extra != 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version < '3.12' and sys_platform != 'linux' and extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version < '3.12' and sys_platform != 'linux' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version < '3.12' and sys_platform != 'linux' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version < '3.12' and sys_platform != 'linux' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version < '3.12' and sys_platform != 'linux' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version < '3.12' and sys_platform != 'linux' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.12' and sys_platform != 'win32' and extra == 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch') or (python_full_version >= '3.12' and sys_platform != 'win32' and extra == 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version < '3.10' and sys_platform == 'linux' and extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version < '3.10' and sys_platform == 'linux' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version < '3.10' and sys_platform == 'linux' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version < '3.10' and sys_platform == 'linux' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version < '3.10' and sys_platform == 'linux' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version < '3.10' and sys_platform == 'linux' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.12' and sys_platform == 'linux' and extra == 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch') or (python_full_version >= '3.12' and sys_platform == 'linux' and extra == 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.10' and extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version >= '3.10' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version >= '3.10' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version >= '3.12' and extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version >= '3.12' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version >= '3.12' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version >= '3.12' and extra == 'extra-13-lightly-train-onnx' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.12' and extra == 'extra-13-lightly-train-onnx' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.12' and extra == 'extra-13-lightly-train-onnx' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.12' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.12' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.12' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.12' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.12' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.12' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.10' and extra != 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.12' and extra != 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.12' and extra != 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.12' and extra != 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (sys_platform == 'win32' and extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (sys_platform == 'win32' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (sys_platform == 'win32' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (sys_platform == 'win32' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (sys_platform == 'win32' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (sys_platform == 'win32' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal')" }, ] wheels = [ { url = "https://files.pythonhosted.org/packages/f8/94/5c26f33738ae35276672f12615a64bd008ed5be6d1ebcb23579285d960a9/nvidia_cusparse-12.6.3.3-py3-none-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:80bcc4662f23f1054ee334a15c72b8940402975e0eab63178fc7e670aa59472c", size = 162155568, upload-time = "2025-09-04T08:33:42.864Z" }, @@ -32184,7 +32186,7 @@ resolution-markers = [ "python_full_version < '3.9' and sys_platform == 'linux'", ] dependencies = [ - { name = "nvidia-nvjitlink-cu12", marker = "(python_full_version < '3.9' and sys_platform != 'win32' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version < '3.9' and sys_platform != 'win32' and extra != 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version < '3.9' and extra == 'group-13-lightly-train-minimal-torch') or (python_full_version < '3.9' and extra == 'extra-13-lightly-train-onnx' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version < '3.9' and extra == 'extra-13-lightly-train-onnx' and extra != 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version < '3.9' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version < '3.9' and extra == 'extra-13-lightly-train-onnxruntime' and extra != 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version < '3.9' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version < '3.9' and extra == 'extra-13-lightly-train-rfdetr' and extra != 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version < '3.9' and extra != 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version < '3.9' and extra != 'group-13-lightly-train-pinned-torch-maximal' and extra != 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.9' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (extra == 'extra-13-lightly-train-onnx' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (extra == 'extra-13-lightly-train-onnxruntime' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (extra == 'extra-13-lightly-train-rfdetr' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (extra == 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal')" }, + { name = "nvidia-nvjitlink-cu12", marker = "(python_full_version < '3.9' and sys_platform == 'linux' and extra == 'group-13-lightly-train-minimal-torch') or (python_full_version < '3.9' and sys_platform == 'linux' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version < '3.9' and sys_platform == 'linux' and extra != 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.9' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.9' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.9' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (sys_platform != 'linux' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (sys_platform != 'linux' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (sys_platform != 'linux' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients')" }, ] wheels = [ { url = "https://files.pythonhosted.org/packages/65/5b/cfaeebf25cd9fdec14338ccb16f6b2c4c7fa9163aefcf057d86b9cc248bb/nvidia_cusparse_cu12-12.1.0.106-py3-none-manylinux1_x86_64.whl", hash = "sha256:f3b50f42cf363f86ab21f720998517a659a48131e8d538dc02f8768237bd884c", size = 195958278, upload-time = "2023-04-19T15:51:49.939Z" }, @@ -32201,7 +32203,7 @@ resolution-markers = [ "(python_full_version == '3.12.*' and platform_machine != 'aarch64' and platform_machine != 's390x' and sys_platform == 'linux') or (python_full_version == '3.12.*' and platform_machine != 's390x' and sys_platform != 'darwin' and sys_platform != 'linux' and sys_platform != 'win32')", ] dependencies = [ - { name = "nvidia-nvjitlink-cu12", marker = "(python_full_version >= '3.10' and python_full_version < '3.12' and platform_machine != 's390x' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.10' and python_full_version < '3.12' and platform_machine != 's390x' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.10' and python_full_version < '3.12' and platform_machine != 's390x' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version < '3.9' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version < '3.9' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version < '3.9' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version < '3.9' and platform_machine != 's390x' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version < '3.9' and platform_machine != 's390x' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version < '3.9' and platform_machine != 's390x' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.10' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version >= '3.10' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version >= '3.10' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version >= '3.12' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version >= '3.12' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-onnx' and extra == 'group-13-lightly-train-minimal-torch') or (python_full_version >= '3.12' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-onnx' and extra != 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.12' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version >= '3.12' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'group-13-lightly-train-minimal-torch') or (python_full_version >= '3.12' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-onnxruntime' and extra != 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.12' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version >= '3.12' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'group-13-lightly-train-minimal-torch') or (python_full_version >= '3.12' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-rfdetr' and extra != 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.12' and platform_machine != 's390x' and extra != 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch') or (python_full_version >= '3.12' and platform_machine != 's390x' and extra != 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.10' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-onnx' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.10' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-onnx' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.10' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-onnx' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.10' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.10' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.10' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.10' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.10' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.10' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.12' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-onnx' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.12' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.12' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.12' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.12' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.12' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.12' and platform_machine != 's390x' and extra != 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version == '3.9.*' and extra == 'group-13-lightly-train-minimal-torch') or (python_full_version == '3.9.*' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version == '3.9.*' and extra != 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version == '3.9.*' and extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version == '3.9.*' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version == '3.9.*' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (platform_machine == 's390x' and extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (platform_machine == 's390x' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (platform_machine == 's390x' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (platform_machine == 's390x' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (platform_machine == 's390x' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (platform_machine == 's390x' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal')" }, + { name = "nvidia-nvjitlink-cu12", marker = "(python_full_version >= '3.10' and python_full_version < '3.12' and platform_machine != 'aarch64' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version >= '3.10' and python_full_version < '3.12' and platform_machine != 'aarch64' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version >= '3.10' and python_full_version < '3.12' and platform_machine != 'aarch64' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version >= '3.10' and python_full_version < '3.12' and platform_machine != 'aarch64' and platform_machine != 's390x' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.10' and python_full_version < '3.12' and platform_machine != 'aarch64' and platform_machine != 's390x' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.10' and python_full_version < '3.12' and platform_machine != 'aarch64' and platform_machine != 's390x' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.12' and platform_machine != 'aarch64' and platform_machine != 's390x' and sys_platform == 'linux' and extra == 'extra-13-lightly-train-onnx' and extra == 'group-13-lightly-train-minimal-torch') or (python_full_version >= '3.12' and platform_machine != 'aarch64' and platform_machine != 's390x' and sys_platform == 'linux' and extra == 'extra-13-lightly-train-onnx' and extra != 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.12' and platform_machine != 'aarch64' and platform_machine != 's390x' and sys_platform == 'linux' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'group-13-lightly-train-minimal-torch') or (python_full_version >= '3.12' and platform_machine != 'aarch64' and platform_machine != 's390x' and sys_platform == 'linux' and extra == 'extra-13-lightly-train-onnxruntime' and extra != 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.12' and platform_machine != 'aarch64' and platform_machine != 's390x' and sys_platform == 'linux' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'group-13-lightly-train-minimal-torch') or (python_full_version >= '3.12' and platform_machine != 'aarch64' and platform_machine != 's390x' and sys_platform == 'linux' and extra == 'extra-13-lightly-train-rfdetr' and extra != 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.12' and platform_machine != 'aarch64' and platform_machine != 's390x' and sys_platform == 'linux' and extra != 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch') or (python_full_version >= '3.12' and platform_machine != 'aarch64' and platform_machine != 's390x' and sys_platform == 'linux' and extra != 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version < '3.9' and platform_machine != 'aarch64' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version < '3.9' and platform_machine != 'aarch64' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version < '3.9' and platform_machine != 'aarch64' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version == '3.9.*' and platform_machine != 'aarch64' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version == '3.9.*' and platform_machine != 'aarch64' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version == '3.9.*' and platform_machine != 'aarch64' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version >= '3.12' and platform_machine != 'aarch64' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version >= '3.12' and platform_machine != 'aarch64' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version >= '3.12' and platform_machine != 'aarch64' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version < '3.9' and platform_machine != 'aarch64' and platform_machine != 's390x' and extra != 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version == '3.9.*' and platform_machine != 'aarch64' and platform_machine != 's390x' and extra != 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.12' and platform_machine != 'aarch64' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.12' and platform_machine != 'aarch64' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.12' and platform_machine != 'aarch64' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.12' and platform_machine != 'aarch64' and platform_machine != 's390x' and extra != 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.12' and platform_machine != 's390x' and sys_platform != 'darwin' and sys_platform != 'linux' and sys_platform != 'win32' and extra == 'extra-13-lightly-train-onnx' and extra == 'group-13-lightly-train-minimal-torch') or (python_full_version >= '3.12' and platform_machine != 's390x' and sys_platform != 'darwin' and sys_platform != 'linux' and sys_platform != 'win32' and extra == 'extra-13-lightly-train-onnx' and extra != 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.12' and platform_machine != 's390x' and sys_platform != 'darwin' and sys_platform != 'linux' and sys_platform != 'win32' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'group-13-lightly-train-minimal-torch') or (python_full_version >= '3.12' and platform_machine != 's390x' and sys_platform != 'darwin' and sys_platform != 'linux' and sys_platform != 'win32' and extra == 'extra-13-lightly-train-onnxruntime' and extra != 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.12' and platform_machine != 's390x' and sys_platform != 'darwin' and sys_platform != 'linux' and sys_platform != 'win32' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'group-13-lightly-train-minimal-torch') or (python_full_version >= '3.12' and platform_machine != 's390x' and sys_platform != 'darwin' and sys_platform != 'linux' and sys_platform != 'win32' and extra == 'extra-13-lightly-train-rfdetr' and extra != 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.12' and platform_machine != 's390x' and sys_platform != 'darwin' and sys_platform != 'linux' and sys_platform != 'win32' and extra != 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch') or (python_full_version >= '3.12' and platform_machine != 's390x' and sys_platform != 'darwin' and sys_platform != 'linux' and sys_platform != 'win32' and extra != 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version == '3.9.*' and platform_machine == 's390x' and sys_platform == 'linux' and extra == 'group-13-lightly-train-minimal-torch') or (python_full_version == '3.9.*' and platform_machine == 's390x' and sys_platform == 'linux' and extra != 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version < '3.12' and platform_machine != 's390x' and sys_platform != 'linux' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version < '3.12' and platform_machine != 's390x' and sys_platform != 'linux' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version < '3.12' and platform_machine != 's390x' and sys_platform != 'linux' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version == '3.9.*' and platform_machine != 'aarch64' and sys_platform == 'linux' and extra == 'extra-13-lightly-train-onnx' and extra != 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch') or (python_full_version == '3.9.*' and platform_machine != 'aarch64' and sys_platform == 'linux' and extra == 'extra-13-lightly-train-onnx' and extra != 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version == '3.9.*' and platform_machine != 'aarch64' and sys_platform == 'linux' and extra == 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch') or (python_full_version == '3.9.*' and platform_machine != 'aarch64' and sys_platform == 'linux' and extra == 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version == '3.9.*' and platform_machine != 'aarch64' and sys_platform == 'linux' and extra == 'extra-13-lightly-train-rfdetr' and extra != 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch') or (python_full_version == '3.9.*' and platform_machine != 'aarch64' and sys_platform == 'linux' and extra == 'extra-13-lightly-train-rfdetr' and extra != 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version < '3.9' and platform_machine != 's390x' and sys_platform == 'linux' and extra == 'extra-13-lightly-train-onnx' and extra != 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version < '3.9' and platform_machine != 's390x' and sys_platform == 'linux' and extra == 'extra-13-lightly-train-onnx' and extra != 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version < '3.9' and platform_machine != 's390x' and sys_platform == 'linux' and extra == 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version < '3.9' and platform_machine != 's390x' and sys_platform == 'linux' and extra == 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version < '3.9' and platform_machine != 's390x' and sys_platform == 'linux' and extra == 'extra-13-lightly-train-rfdetr' and extra != 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version < '3.9' and platform_machine != 's390x' and sys_platform == 'linux' and extra == 'extra-13-lightly-train-rfdetr' and extra != 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version == '3.9.*' and platform_machine != 'aarch64' and sys_platform == 'linux' and extra != 'extra-13-lightly-train-onnx' and extra != 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-rfdetr' and extra == 'group-13-lightly-train-minimal-torch') or (python_full_version == '3.9.*' and platform_machine != 'aarch64' and sys_platform == 'linux' and extra != 'extra-13-lightly-train-onnx' and extra != 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-rfdetr' and extra != 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version < '3.9' and platform_machine != 's390x' and sys_platform == 'linux' and extra != 'extra-13-lightly-train-onnx' and extra != 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-rfdetr' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version < '3.9' and platform_machine != 's390x' and sys_platform == 'linux' and extra != 'extra-13-lightly-train-onnx' and extra != 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-rfdetr' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version != '3.9.*' and platform_machine == 's390x' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version != '3.9.*' and platform_machine == 's390x' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version != '3.9.*' and platform_machine == 's390x' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (platform_machine == 's390x' and sys_platform != 'linux' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (platform_machine == 's390x' and sys_platform != 'linux' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (platform_machine == 'aarch64' and sys_platform == 'linux' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (platform_machine == 'aarch64' and sys_platform == 'linux' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (platform_machine != 's390x' and sys_platform != 'linux' and extra == 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (platform_machine != 's390x' and sys_platform != 'linux' and extra == 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (platform_machine != 's390x' and sys_platform != 'linux' and extra == 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (platform_machine == 'aarch64' and extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (platform_machine == 'aarch64' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (platform_machine == 'aarch64' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (platform_machine == 's390x' and extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (platform_machine == 's390x' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (platform_machine == 's390x' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (platform_machine == 'aarch64' and extra != 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (platform_machine == 's390x' and extra != 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (sys_platform != 'linux' and extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (sys_platform != 'linux' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (sys_platform != 'linux' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (sys_platform == 'darwin' and extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (sys_platform == 'darwin' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (sys_platform == 'darwin' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (sys_platform == 'darwin' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (sys_platform == 'darwin' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (sys_platform == 'darwin' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (sys_platform == 'win32' and extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (sys_platform == 'win32' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (sys_platform == 'win32' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (sys_platform == 'win32' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (sys_platform == 'win32' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (sys_platform == 'win32' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (sys_platform != 'linux' and extra != 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal')" }, ] wheels = [ { url = "https://files.pythonhosted.org/packages/bc/f7/cd777c4109681367721b00a106f491e0d0d15cfa1fd59672ce580ce42a97/nvidia_cusparse_cu12-12.5.8.93-py3-none-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:9b6c161cb130be1a07a27ea6923df8141f3c295852f4b260c65f18f3e0a091dc", size = 288117129, upload-time = "2025-03-07T01:47:40.407Z" }, @@ -33620,67 +33622,43 @@ source = { registry = "https://pypi.org/simple" } resolution-markers = [ "python_full_version == '3.11.*' and platform_machine != 's390x' and sys_platform == 'win32' and extra != 'extra-13-lightly-train-onnx' and extra != 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-minimal-torch' and extra != 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal'", "python_full_version == '3.11.*' and platform_machine == 's390x' and sys_platform == 'win32' and extra != 'extra-13-lightly-train-onnx' and extra != 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-minimal-torch' and extra != 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal'", - "python_full_version == '3.10.*' and platform_machine != 's390x' and sys_platform == 'win32' and extra != 'extra-13-lightly-train-onnx' and extra != 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-minimal-torch' and extra != 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal'", - "python_full_version == '3.10.*' and platform_machine == 's390x' and sys_platform == 'win32' and extra != 'extra-13-lightly-train-onnx' and extra != 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-minimal-torch' and extra != 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal'", "python_full_version == '3.11.*' and platform_machine == 'aarch64' and sys_platform == 'linux' and extra != 'extra-13-lightly-train-onnx' and extra != 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-minimal-torch' and extra != 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal'", "python_full_version == '3.11.*' and platform_machine != 'aarch64' and platform_machine != 's390x' and sys_platform == 'linux' and extra != 'extra-13-lightly-train-onnx' and extra != 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-minimal-torch' and extra != 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal'", "python_full_version == '3.11.*' and platform_machine == 's390x' and sys_platform == 'linux' and extra != 'extra-13-lightly-train-onnx' and extra != 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-minimal-torch' and extra != 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal'", - "python_full_version == '3.10.*' and platform_machine == 'aarch64' and sys_platform == 'linux' and extra != 'extra-13-lightly-train-onnx' and extra != 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-minimal-torch' and extra != 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal'", - "python_full_version == '3.10.*' and platform_machine != 'aarch64' and platform_machine != 's390x' and sys_platform == 'linux' and extra != 'extra-13-lightly-train-onnx' and extra != 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-minimal-torch' and extra != 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal'", - "python_full_version == '3.10.*' and platform_machine == 's390x' and sys_platform == 'linux' and extra != 'extra-13-lightly-train-onnx' and extra != 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-minimal-torch' and extra != 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal'", "python_full_version == '3.11.*' and platform_machine != 's390x' and sys_platform == 'darwin' and extra != 'extra-13-lightly-train-onnx' and extra != 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-minimal-torch' and extra != 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal'", "python_full_version == '3.11.*' and platform_machine == 's390x' and sys_platform == 'darwin' and extra != 'extra-13-lightly-train-onnx' and extra != 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-minimal-torch' and extra != 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal'", "python_full_version == '3.11.*' and platform_machine != 's390x' and sys_platform != 'darwin' and sys_platform != 'linux' and sys_platform != 'win32' and extra != 'extra-13-lightly-train-onnx' and extra != 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-minimal-torch' and extra != 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal'", "python_full_version == '3.11.*' and platform_machine == 's390x' and sys_platform != 'darwin' and sys_platform != 'linux' and sys_platform != 'win32' and extra != 'extra-13-lightly-train-onnx' and extra != 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-minimal-torch' and extra != 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal'", - "python_full_version == '3.10.*' and platform_machine != 's390x' and sys_platform == 'darwin' and extra != 'extra-13-lightly-train-onnx' and extra != 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-minimal-torch' and extra != 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal'", - "python_full_version == '3.10.*' and platform_machine == 's390x' and sys_platform == 'darwin' and extra != 'extra-13-lightly-train-onnx' and extra != 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-minimal-torch' and extra != 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal'", - "python_full_version == '3.10.*' and platform_machine != 's390x' and sys_platform != 'darwin' and sys_platform != 'linux' and sys_platform != 'win32' and extra != 'extra-13-lightly-train-onnx' and extra != 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-minimal-torch' and extra != 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal'", - "python_full_version == '3.10.*' and platform_machine == 's390x' and sys_platform != 'darwin' and sys_platform != 'linux' and sys_platform != 'win32' and extra != 'extra-13-lightly-train-onnx' and extra != 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-minimal-torch' and extra != 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal'", "python_full_version == '3.9.*' and sys_platform == 'win32' and extra != 'extra-13-lightly-train-onnx' and extra != 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-minimal-torch' and extra != 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal'", "python_full_version == '3.9.*' and platform_machine == 'aarch64' and sys_platform == 'linux' and extra != 'extra-13-lightly-train-onnx' and extra != 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-minimal-torch' and extra != 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal'", "python_full_version == '3.9.*' and platform_machine != 'aarch64' and sys_platform == 'linux' and extra != 'extra-13-lightly-train-onnx' and extra != 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-minimal-torch' and extra != 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal'", "python_full_version == '3.9.*' and platform_machine == 'arm64' and sys_platform == 'darwin' and extra != 'extra-13-lightly-train-onnx' and extra != 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-minimal-torch' and extra != 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal'", "(python_full_version == '3.9.*' and platform_machine != 'arm64' and sys_platform == 'darwin' and extra != 'extra-13-lightly-train-onnx' and extra != 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-minimal-torch' and extra != 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version == '3.9.*' and sys_platform != 'darwin' and sys_platform != 'linux' and sys_platform != 'win32' and extra != 'extra-13-lightly-train-onnx' and extra != 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-minimal-torch' and extra != 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal')", "python_full_version == '3.11.*' and sys_platform == 'win32' and extra != 'extra-13-lightly-train-onnx' and extra != 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra != 'group-13-lightly-train-pinned-torch-minimal'", - "python_full_version == '3.10.*' and sys_platform == 'win32' and extra != 'extra-13-lightly-train-onnx' and extra != 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra != 'group-13-lightly-train-pinned-torch-minimal'", "python_full_version == '3.11.*' and platform_machine == 'aarch64' and sys_platform == 'linux' and extra != 'extra-13-lightly-train-onnx' and extra != 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra != 'group-13-lightly-train-pinned-torch-minimal'", "python_full_version == '3.11.*' and platform_machine != 'aarch64' and sys_platform == 'linux' and extra != 'extra-13-lightly-train-onnx' and extra != 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra != 'group-13-lightly-train-pinned-torch-minimal'", - "python_full_version == '3.10.*' and platform_machine == 'aarch64' and sys_platform == 'linux' and extra != 'extra-13-lightly-train-onnx' and extra != 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra != 'group-13-lightly-train-pinned-torch-minimal'", - "python_full_version == '3.10.*' and platform_machine != 'aarch64' and sys_platform == 'linux' and extra != 'extra-13-lightly-train-onnx' and extra != 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra != 'group-13-lightly-train-pinned-torch-minimal'", "python_full_version == '3.11.*' and sys_platform == 'darwin' and extra != 'extra-13-lightly-train-onnx' and extra != 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra != 'group-13-lightly-train-pinned-torch-minimal'", "python_full_version == '3.11.*' and sys_platform != 'darwin' and sys_platform != 'linux' and sys_platform != 'win32' and extra != 'extra-13-lightly-train-onnx' and extra != 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra != 'group-13-lightly-train-pinned-torch-minimal'", - "python_full_version == '3.10.*' and sys_platform == 'darwin' and extra != 'extra-13-lightly-train-onnx' and extra != 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra != 'group-13-lightly-train-pinned-torch-minimal'", - "python_full_version == '3.10.*' and sys_platform != 'darwin' and sys_platform != 'linux' and sys_platform != 'win32' and extra != 'extra-13-lightly-train-onnx' and extra != 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra != 'group-13-lightly-train-pinned-torch-minimal'", "python_full_version == '3.9.*' and sys_platform == 'win32' and extra != 'extra-13-lightly-train-onnx' and extra != 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra != 'group-13-lightly-train-pinned-torch-minimal'", "python_full_version == '3.9.*' and platform_machine == 'aarch64' and sys_platform == 'linux' and extra != 'extra-13-lightly-train-onnx' and extra != 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra != 'group-13-lightly-train-pinned-torch-minimal'", "python_full_version == '3.9.*' and platform_machine != 'aarch64' and sys_platform == 'linux' and extra != 'extra-13-lightly-train-onnx' and extra != 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra != 'group-13-lightly-train-pinned-torch-minimal'", "python_full_version == '3.9.*' and platform_machine == 'arm64' and sys_platform == 'darwin' and extra != 'extra-13-lightly-train-onnx' and extra != 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra != 'group-13-lightly-train-pinned-torch-minimal'", "(python_full_version == '3.9.*' and platform_machine != 'arm64' and sys_platform == 'darwin' and extra != 'extra-13-lightly-train-onnx' and extra != 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra != 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version == '3.9.*' and sys_platform != 'darwin' and sys_platform != 'linux' and sys_platform != 'win32' and extra != 'extra-13-lightly-train-onnx' and extra != 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra != 'group-13-lightly-train-pinned-torch-minimal')", "python_full_version == '3.11.*' and sys_platform == 'win32' and extra != 'extra-13-lightly-train-onnx' and extra != 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch' and extra != 'group-13-lightly-train-pinned-torch-maximal' and extra != 'group-13-lightly-train-pinned-torch-minimal'", - "python_full_version == '3.10.*' and sys_platform == 'win32' and extra != 'extra-13-lightly-train-onnx' and extra != 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch' and extra != 'group-13-lightly-train-pinned-torch-maximal' and extra != 'group-13-lightly-train-pinned-torch-minimal'", "python_full_version == '3.11.*' and platform_machine == 'aarch64' and sys_platform == 'linux' and extra != 'extra-13-lightly-train-onnx' and extra != 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch' and extra != 'group-13-lightly-train-pinned-torch-maximal' and extra != 'group-13-lightly-train-pinned-torch-minimal'", "python_full_version == '3.11.*' and platform_machine != 'aarch64' and sys_platform == 'linux' and extra != 'extra-13-lightly-train-onnx' and extra != 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch' and extra != 'group-13-lightly-train-pinned-torch-maximal' and extra != 'group-13-lightly-train-pinned-torch-minimal'", - "python_full_version == '3.10.*' and platform_machine == 'aarch64' and sys_platform == 'linux' and extra != 'extra-13-lightly-train-onnx' and extra != 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch' and extra != 'group-13-lightly-train-pinned-torch-maximal' and extra != 'group-13-lightly-train-pinned-torch-minimal'", - "python_full_version == '3.10.*' and platform_machine != 'aarch64' and sys_platform == 'linux' and extra != 'extra-13-lightly-train-onnx' and extra != 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch' and extra != 'group-13-lightly-train-pinned-torch-maximal' and extra != 'group-13-lightly-train-pinned-torch-minimal'", "python_full_version == '3.11.*' and sys_platform == 'darwin' and extra != 'extra-13-lightly-train-onnx' and extra != 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch' and extra != 'group-13-lightly-train-pinned-torch-maximal' and extra != 'group-13-lightly-train-pinned-torch-minimal'", "python_full_version == '3.11.*' and sys_platform != 'darwin' and sys_platform != 'linux' and sys_platform != 'win32' and extra != 'extra-13-lightly-train-onnx' and extra != 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch' and extra != 'group-13-lightly-train-pinned-torch-maximal' and extra != 'group-13-lightly-train-pinned-torch-minimal'", - "python_full_version == '3.10.*' and sys_platform == 'darwin' and extra != 'extra-13-lightly-train-onnx' and extra != 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch' and extra != 'group-13-lightly-train-pinned-torch-maximal' and extra != 'group-13-lightly-train-pinned-torch-minimal'", - "python_full_version == '3.10.*' and sys_platform != 'darwin' and sys_platform != 'linux' and sys_platform != 'win32' and extra != 'extra-13-lightly-train-onnx' and extra != 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch' and extra != 'group-13-lightly-train-pinned-torch-maximal' and extra != 'group-13-lightly-train-pinned-torch-minimal'", "python_full_version == '3.9.*' and sys_platform == 'win32' and extra != 'extra-13-lightly-train-onnx' and extra != 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch' and extra != 'group-13-lightly-train-pinned-torch-maximal' and extra != 'group-13-lightly-train-pinned-torch-minimal'", "python_full_version == '3.9.*' and platform_machine == 'aarch64' and sys_platform == 'linux' and extra != 'extra-13-lightly-train-onnx' and extra != 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch' and extra != 'group-13-lightly-train-pinned-torch-maximal' and extra != 'group-13-lightly-train-pinned-torch-minimal'", "python_full_version == '3.9.*' and platform_machine != 'aarch64' and sys_platform == 'linux' and extra != 'extra-13-lightly-train-onnx' and extra != 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch' and extra != 'group-13-lightly-train-pinned-torch-maximal' and extra != 'group-13-lightly-train-pinned-torch-minimal'", "python_full_version == '3.9.*' and platform_machine == 'arm64' and sys_platform == 'darwin' and extra != 'extra-13-lightly-train-onnx' and extra != 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch' and extra != 'group-13-lightly-train-pinned-torch-maximal' and extra != 'group-13-lightly-train-pinned-torch-minimal'", "(python_full_version == '3.9.*' and platform_machine != 'arm64' and sys_platform == 'darwin' and extra != 'extra-13-lightly-train-onnx' and extra != 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch' and extra != 'group-13-lightly-train-pinned-torch-maximal' and extra != 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version == '3.9.*' and sys_platform != 'darwin' and sys_platform != 'linux' and sys_platform != 'win32' and extra != 'extra-13-lightly-train-onnx' and extra != 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch' and extra != 'group-13-lightly-train-pinned-torch-maximal' and extra != 'group-13-lightly-train-pinned-torch-minimal')", "python_full_version == '3.11.*' and sys_platform == 'win32' and extra != 'extra-13-lightly-train-onnx' and extra != 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-minimal-torch' and extra != 'group-13-lightly-train-pinned-torch-maximal' and extra != 'group-13-lightly-train-pinned-torch-minimal'", - "python_full_version == '3.10.*' and sys_platform == 'win32' and extra != 'extra-13-lightly-train-onnx' and extra != 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-minimal-torch' and extra != 'group-13-lightly-train-pinned-torch-maximal' and extra != 'group-13-lightly-train-pinned-torch-minimal'", "python_full_version == '3.11.*' and platform_machine == 'aarch64' and sys_platform == 'linux' and extra != 'extra-13-lightly-train-onnx' and extra != 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-minimal-torch' and extra != 'group-13-lightly-train-pinned-torch-maximal' and extra != 'group-13-lightly-train-pinned-torch-minimal'", "python_full_version == '3.11.*' and platform_machine != 'aarch64' and sys_platform == 'linux' and extra != 'extra-13-lightly-train-onnx' and extra != 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-minimal-torch' and extra != 'group-13-lightly-train-pinned-torch-maximal' and extra != 'group-13-lightly-train-pinned-torch-minimal'", - "python_full_version == '3.10.*' and platform_machine == 'aarch64' and sys_platform == 'linux' and extra != 'extra-13-lightly-train-onnx' and extra != 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-minimal-torch' and extra != 'group-13-lightly-train-pinned-torch-maximal' and extra != 'group-13-lightly-train-pinned-torch-minimal'", - "python_full_version == '3.10.*' and platform_machine != 'aarch64' and sys_platform == 'linux' and extra != 'extra-13-lightly-train-onnx' and extra != 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-minimal-torch' and extra != 'group-13-lightly-train-pinned-torch-maximal' and extra != 'group-13-lightly-train-pinned-torch-minimal'", "python_full_version == '3.11.*' and sys_platform == 'darwin' and extra != 'extra-13-lightly-train-onnx' and extra != 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-minimal-torch' and extra != 'group-13-lightly-train-pinned-torch-maximal' and extra != 'group-13-lightly-train-pinned-torch-minimal'", "python_full_version == '3.11.*' and sys_platform != 'darwin' and sys_platform != 'linux' and sys_platform != 'win32' and extra != 'extra-13-lightly-train-onnx' and extra != 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-minimal-torch' and extra != 'group-13-lightly-train-pinned-torch-maximal' and extra != 'group-13-lightly-train-pinned-torch-minimal'", - "python_full_version == '3.10.*' and sys_platform == 'darwin' and extra != 'extra-13-lightly-train-onnx' and extra != 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-minimal-torch' and extra != 'group-13-lightly-train-pinned-torch-maximal' and extra != 'group-13-lightly-train-pinned-torch-minimal'", - "python_full_version == '3.10.*' and sys_platform != 'darwin' and sys_platform != 'linux' and sys_platform != 'win32' and extra != 'extra-13-lightly-train-onnx' and extra != 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-minimal-torch' and extra != 'group-13-lightly-train-pinned-torch-maximal' and extra != 'group-13-lightly-train-pinned-torch-minimal'", "python_full_version == '3.9.*' and sys_platform == 'win32' and extra != 'extra-13-lightly-train-onnx' and extra != 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-minimal-torch' and extra != 'group-13-lightly-train-pinned-torch-maximal' and extra != 'group-13-lightly-train-pinned-torch-minimal'", "python_full_version == '3.9.*' and platform_machine == 'aarch64' and sys_platform == 'linux' and extra != 'extra-13-lightly-train-onnx' and extra != 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-minimal-torch' and extra != 'group-13-lightly-train-pinned-torch-maximal' and extra != 'group-13-lightly-train-pinned-torch-minimal'", "python_full_version == '3.9.*' and platform_machine != 'aarch64' and sys_platform == 'linux' and extra != 'extra-13-lightly-train-onnx' and extra != 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-minimal-torch' and extra != 'group-13-lightly-train-pinned-torch-maximal' and extra != 'group-13-lightly-train-pinned-torch-minimal'", @@ -33768,7 +33746,7 @@ resolution-markers = [ "(python_full_version == '3.9.*' and platform_machine != 'arm64' and sys_platform == 'darwin' and extra != 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-minimal-torch' and extra != 'group-13-lightly-train-pinned-torch-maximal' and extra != 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version == '3.9.*' and sys_platform != 'darwin' and sys_platform != 'linux' and sys_platform != 'win32' and extra != 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-minimal-torch' and extra != 'group-13-lightly-train-pinned-torch-maximal' and extra != 'group-13-lightly-train-pinned-torch-minimal')", ] dependencies = [ - { name = "numpy", version = "1.23.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version == '3.9.*' or python_full_version == '3.11.*' or (python_full_version == '3.10.*' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version < '3.9' and extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version < '3.9' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version < '3.9' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version < '3.9' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version < '3.9' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version < '3.9' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.12' and extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version >= '3.12' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version >= '3.12' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version >= '3.12' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.12' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.12' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version == '3.10.*' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version == '3.10.*' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version == '3.10.*' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal')" }, + { name = "numpy", version = "1.23.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version == '3.9.*' or python_full_version == '3.11.*' or (python_full_version < '3.9' and extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version < '3.9' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version < '3.9' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version < '3.9' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version < '3.9' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version < '3.9' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version == '3.10.*' and extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version == '3.10.*' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version == '3.10.*' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version == '3.10.*' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version == '3.10.*' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version == '3.10.*' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.12' and extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version >= '3.12' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version >= '3.12' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version >= '3.12' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.12' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.12' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal')" }, ] sdist = { url = "https://files.pythonhosted.org/packages/4b/88/4ad713bd596cb82738cbf7b0549d57e3544a8f4771f6d5901715a73e3632/opencv-python-headless-4.7.0.72.tar.gz", hash = "sha256:eea59caa92b28b197f9d2a2dd8275ca3869718b2a857c8e53203de6ef3f9f4db", size = 91110689, upload-time = "2023-02-22T19:13:26.183Z" } wheels = [ @@ -33785,28 +33763,185 @@ name = "opencv-python-headless" version = "4.10.0.84" source = { registry = "https://pypi.org/simple" } resolution-markers = [ - "python_full_version >= '3.13' and platform_machine != 's390x' and sys_platform == 'win32'", - "python_full_version == '3.12.*' and platform_machine != 's390x' and sys_platform == 'win32'", - "python_full_version >= '3.13' and platform_machine != 's390x' and sys_platform == 'darwin'", - "python_full_version >= '3.13' and platform_machine == 'aarch64' and sys_platform == 'linux'", - "(python_full_version >= '3.13' and platform_machine != 'aarch64' and platform_machine != 's390x' and sys_platform == 'linux') or (python_full_version >= '3.13' and platform_machine != 's390x' and sys_platform != 'darwin' and sys_platform != 'linux' and sys_platform != 'win32')", - "python_full_version == '3.12.*' and platform_machine != 's390x' and sys_platform == 'darwin'", - "python_full_version == '3.12.*' and platform_machine == 'aarch64' and sys_platform == 'linux'", - "(python_full_version == '3.12.*' and platform_machine != 'aarch64' and platform_machine != 's390x' and sys_platform == 'linux') or (python_full_version == '3.12.*' and platform_machine != 's390x' and sys_platform != 'darwin' and sys_platform != 'linux' and sys_platform != 'win32')", - "python_full_version >= '3.13' and platform_machine == 's390x' and sys_platform == 'win32'", - "python_full_version == '3.12.*' and platform_machine == 's390x' and sys_platform == 'win32'", - "python_full_version >= '3.13' and platform_machine == 's390x' and sys_platform == 'darwin'", - "python_full_version >= '3.13' and platform_machine == 's390x' and sys_platform != 'darwin' and sys_platform != 'win32'", - "python_full_version == '3.12.*' and platform_machine == 's390x' and sys_platform == 'darwin'", - "python_full_version == '3.12.*' and platform_machine == 's390x' and sys_platform != 'darwin' and sys_platform != 'win32'", - "python_full_version == '3.10.*' and sys_platform == 'win32'", - "python_full_version == '3.10.*' and platform_machine == 'aarch64' and sys_platform == 'linux'", - "python_full_version == '3.10.*' and platform_machine != 'aarch64' and sys_platform == 'linux'", - "python_full_version == '3.10.*' and sys_platform == 'darwin'", - "python_full_version == '3.10.*' and sys_platform != 'darwin' and sys_platform != 'linux' and sys_platform != 'win32'", + "python_full_version == '3.10.*' and platform_machine != 's390x' and sys_platform == 'win32' and extra != 'extra-13-lightly-train-onnx' and extra != 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-minimal-torch' and extra != 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal'", + "python_full_version == '3.10.*' and platform_machine == 's390x' and sys_platform == 'win32' and extra != 'extra-13-lightly-train-onnx' and extra != 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-minimal-torch' and extra != 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal'", + "python_full_version == '3.10.*' and platform_machine == 'aarch64' and sys_platform == 'linux' and extra != 'extra-13-lightly-train-onnx' and extra != 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-minimal-torch' and extra != 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal'", + "python_full_version == '3.10.*' and platform_machine != 'aarch64' and platform_machine != 's390x' and sys_platform == 'linux' and extra != 'extra-13-lightly-train-onnx' and extra != 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-minimal-torch' and extra != 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal'", + "python_full_version == '3.10.*' and platform_machine == 's390x' and sys_platform == 'linux' and extra != 'extra-13-lightly-train-onnx' and extra != 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-minimal-torch' and extra != 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal'", + "python_full_version == '3.10.*' and platform_machine != 's390x' and sys_platform == 'darwin' and extra != 'extra-13-lightly-train-onnx' and extra != 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-minimal-torch' and extra != 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal'", + "python_full_version == '3.10.*' and platform_machine == 's390x' and sys_platform == 'darwin' and extra != 'extra-13-lightly-train-onnx' and extra != 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-minimal-torch' and extra != 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal'", + "python_full_version == '3.10.*' and platform_machine != 's390x' and sys_platform != 'darwin' and sys_platform != 'linux' and sys_platform != 'win32' and extra != 'extra-13-lightly-train-onnx' and extra != 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-minimal-torch' and extra != 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal'", + "python_full_version == '3.10.*' and platform_machine == 's390x' and sys_platform != 'darwin' and sys_platform != 'linux' and sys_platform != 'win32' and extra != 'extra-13-lightly-train-onnx' and extra != 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-minimal-torch' and extra != 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal'", + "python_full_version == '3.10.*' and sys_platform == 'win32' and extra != 'extra-13-lightly-train-onnx' and extra != 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra != 'group-13-lightly-train-pinned-torch-minimal'", + "python_full_version == '3.10.*' and platform_machine == 'aarch64' and sys_platform == 'linux' and extra != 'extra-13-lightly-train-onnx' and extra != 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra != 'group-13-lightly-train-pinned-torch-minimal'", + "python_full_version == '3.10.*' and platform_machine != 'aarch64' and sys_platform == 'linux' and extra != 'extra-13-lightly-train-onnx' and extra != 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra != 'group-13-lightly-train-pinned-torch-minimal'", + "python_full_version == '3.10.*' and sys_platform == 'darwin' and extra != 'extra-13-lightly-train-onnx' and extra != 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra != 'group-13-lightly-train-pinned-torch-minimal'", + "python_full_version == '3.10.*' and sys_platform != 'darwin' and sys_platform != 'linux' and sys_platform != 'win32' and extra != 'extra-13-lightly-train-onnx' and extra != 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra != 'group-13-lightly-train-pinned-torch-minimal'", + "python_full_version == '3.10.*' and sys_platform == 'win32' and extra != 'extra-13-lightly-train-onnx' and extra != 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch' and extra != 'group-13-lightly-train-pinned-torch-maximal' and extra != 'group-13-lightly-train-pinned-torch-minimal'", + "python_full_version == '3.10.*' and platform_machine == 'aarch64' and sys_platform == 'linux' and extra != 'extra-13-lightly-train-onnx' and extra != 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch' and extra != 'group-13-lightly-train-pinned-torch-maximal' and extra != 'group-13-lightly-train-pinned-torch-minimal'", + "python_full_version == '3.10.*' and platform_machine != 'aarch64' and sys_platform == 'linux' and extra != 'extra-13-lightly-train-onnx' and extra != 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch' and extra != 'group-13-lightly-train-pinned-torch-maximal' and extra != 'group-13-lightly-train-pinned-torch-minimal'", + "python_full_version == '3.10.*' and sys_platform == 'darwin' and extra != 'extra-13-lightly-train-onnx' and extra != 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch' and extra != 'group-13-lightly-train-pinned-torch-maximal' and extra != 'group-13-lightly-train-pinned-torch-minimal'", + "python_full_version == '3.10.*' and sys_platform != 'darwin' and sys_platform != 'linux' and sys_platform != 'win32' and extra != 'extra-13-lightly-train-onnx' and extra != 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch' and extra != 'group-13-lightly-train-pinned-torch-maximal' and extra != 'group-13-lightly-train-pinned-torch-minimal'", + "python_full_version == '3.10.*' and sys_platform == 'win32' and extra != 'extra-13-lightly-train-onnx' and extra != 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-minimal-torch' and extra != 'group-13-lightly-train-pinned-torch-maximal' and extra != 'group-13-lightly-train-pinned-torch-minimal'", + "python_full_version == '3.10.*' and platform_machine == 'aarch64' and sys_platform == 'linux' and extra != 'extra-13-lightly-train-onnx' and extra != 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-minimal-torch' and extra != 'group-13-lightly-train-pinned-torch-maximal' and extra != 'group-13-lightly-train-pinned-torch-minimal'", + "python_full_version == '3.10.*' and platform_machine != 'aarch64' and sys_platform == 'linux' and extra != 'extra-13-lightly-train-onnx' and extra != 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-minimal-torch' and extra != 'group-13-lightly-train-pinned-torch-maximal' and extra != 'group-13-lightly-train-pinned-torch-minimal'", + "python_full_version == '3.10.*' and sys_platform == 'darwin' and extra != 'extra-13-lightly-train-onnx' and extra != 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-minimal-torch' and extra != 'group-13-lightly-train-pinned-torch-maximal' and extra != 'group-13-lightly-train-pinned-torch-minimal'", + "python_full_version == '3.10.*' and sys_platform != 'darwin' and sys_platform != 'linux' and sys_platform != 'win32' and extra != 'extra-13-lightly-train-onnx' and extra != 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-minimal-torch' and extra != 'group-13-lightly-train-pinned-torch-maximal' and extra != 'group-13-lightly-train-pinned-torch-minimal'", + "python_full_version >= '3.13' and platform_machine != 's390x' and sys_platform == 'win32' and extra == 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-minimal-torch' and extra != 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal'", + "python_full_version == '3.12.*' and platform_machine != 's390x' and sys_platform == 'win32' and extra == 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-minimal-torch' and extra != 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal'", + "python_full_version >= '3.13' and platform_machine != 's390x' and sys_platform == 'darwin' and extra == 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-minimal-torch' and extra != 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal'", + "python_full_version >= '3.13' and platform_machine == 'aarch64' and sys_platform == 'linux' and extra == 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-minimal-torch' and extra != 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal'", + "(python_full_version >= '3.13' and platform_machine != 'aarch64' and platform_machine != 's390x' and sys_platform == 'linux' and extra == 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-minimal-torch' and extra != 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.13' and platform_machine != 's390x' and sys_platform != 'darwin' and sys_platform != 'linux' and sys_platform != 'win32' and extra == 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-minimal-torch' and extra != 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal')", + "python_full_version == '3.12.*' and platform_machine != 's390x' and sys_platform == 'darwin' and extra == 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-minimal-torch' and extra != 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal'", + "python_full_version == '3.12.*' and platform_machine == 'aarch64' and sys_platform == 'linux' and extra == 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-minimal-torch' and extra != 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal'", + "(python_full_version == '3.12.*' and platform_machine != 'aarch64' and platform_machine != 's390x' and sys_platform == 'linux' and extra == 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-minimal-torch' and extra != 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version == '3.12.*' and platform_machine != 's390x' and sys_platform != 'darwin' and sys_platform != 'linux' and sys_platform != 'win32' and extra == 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-minimal-torch' and extra != 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal')", + "python_full_version >= '3.13' and platform_machine == 's390x' and sys_platform == 'win32' and extra == 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-minimal-torch' and extra != 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal'", + "python_full_version == '3.12.*' and platform_machine == 's390x' and sys_platform == 'win32' and extra == 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-minimal-torch' and extra != 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal'", + "python_full_version >= '3.13' and platform_machine == 's390x' and sys_platform == 'darwin' and extra == 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-minimal-torch' and extra != 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal'", + "python_full_version >= '3.13' and platform_machine == 's390x' and sys_platform != 'darwin' and sys_platform != 'win32' and extra == 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-minimal-torch' and extra != 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal'", + "python_full_version == '3.12.*' and platform_machine == 's390x' and sys_platform == 'darwin' and extra == 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-minimal-torch' and extra != 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal'", + "python_full_version == '3.12.*' and platform_machine == 's390x' and sys_platform != 'darwin' and sys_platform != 'win32' and extra == 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-minimal-torch' and extra != 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal'", + "python_full_version == '3.10.*' and sys_platform == 'win32' and extra == 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-minimal-torch' and extra != 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal'", + "python_full_version == '3.10.*' and platform_machine == 'aarch64' and sys_platform == 'linux' and extra == 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-minimal-torch' and extra != 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal'", + "python_full_version == '3.10.*' and platform_machine != 'aarch64' and sys_platform == 'linux' and extra == 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-minimal-torch' and extra != 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal'", + "python_full_version == '3.10.*' and sys_platform == 'darwin' and extra == 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-minimal-torch' and extra != 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal'", + "python_full_version == '3.10.*' and sys_platform != 'darwin' and sys_platform != 'linux' and sys_platform != 'win32' and extra == 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-minimal-torch' and extra != 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal'", + "python_full_version >= '3.13' and platform_machine != 's390x' and sys_platform == 'win32' and extra == 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra != 'group-13-lightly-train-pinned-torch-minimal'", + "python_full_version == '3.12.*' and platform_machine != 's390x' and sys_platform == 'win32' and extra == 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra != 'group-13-lightly-train-pinned-torch-minimal'", + "python_full_version >= '3.13' and platform_machine != 's390x' and sys_platform == 'darwin' and extra == 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra != 'group-13-lightly-train-pinned-torch-minimal'", + "python_full_version >= '3.13' and platform_machine == 'aarch64' and sys_platform == 'linux' and extra == 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra != 'group-13-lightly-train-pinned-torch-minimal'", + "(python_full_version >= '3.13' and platform_machine != 'aarch64' and platform_machine != 's390x' and sys_platform == 'linux' and extra == 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra != 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.13' and platform_machine != 's390x' and sys_platform != 'darwin' and sys_platform != 'linux' and sys_platform != 'win32' and extra == 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra != 'group-13-lightly-train-pinned-torch-minimal')", + "python_full_version == '3.12.*' and platform_machine != 's390x' and sys_platform == 'darwin' and extra == 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra != 'group-13-lightly-train-pinned-torch-minimal'", + "python_full_version == '3.12.*' and platform_machine == 'aarch64' and sys_platform == 'linux' and extra == 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra != 'group-13-lightly-train-pinned-torch-minimal'", + "(python_full_version == '3.12.*' and platform_machine != 'aarch64' and platform_machine != 's390x' and sys_platform == 'linux' and extra == 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra != 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version == '3.12.*' and platform_machine != 's390x' and sys_platform != 'darwin' and sys_platform != 'linux' and sys_platform != 'win32' and extra == 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra != 'group-13-lightly-train-pinned-torch-minimal')", + "python_full_version >= '3.13' and platform_machine == 's390x' and sys_platform == 'win32' and extra == 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra != 'group-13-lightly-train-pinned-torch-minimal'", + "python_full_version == '3.12.*' and platform_machine == 's390x' and sys_platform == 'win32' and extra == 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra != 'group-13-lightly-train-pinned-torch-minimal'", + "python_full_version >= '3.13' and platform_machine == 's390x' and sys_platform == 'darwin' and extra == 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra != 'group-13-lightly-train-pinned-torch-minimal'", + "python_full_version >= '3.13' and platform_machine == 's390x' and sys_platform != 'darwin' and sys_platform != 'win32' and extra == 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra != 'group-13-lightly-train-pinned-torch-minimal'", + "python_full_version == '3.12.*' and platform_machine == 's390x' and sys_platform == 'darwin' and extra == 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra != 'group-13-lightly-train-pinned-torch-minimal'", + "python_full_version == '3.12.*' and platform_machine == 's390x' and sys_platform != 'darwin' and sys_platform != 'win32' and extra == 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra != 'group-13-lightly-train-pinned-torch-minimal'", + "python_full_version == '3.10.*' and sys_platform == 'win32' and extra == 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra != 'group-13-lightly-train-pinned-torch-minimal'", + "python_full_version == '3.10.*' and platform_machine == 'aarch64' and sys_platform == 'linux' and extra == 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra != 'group-13-lightly-train-pinned-torch-minimal'", + "python_full_version == '3.10.*' and platform_machine != 'aarch64' and sys_platform == 'linux' and extra == 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra != 'group-13-lightly-train-pinned-torch-minimal'", + "python_full_version == '3.10.*' and sys_platform == 'darwin' and extra == 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra != 'group-13-lightly-train-pinned-torch-minimal'", + "python_full_version == '3.10.*' and sys_platform != 'darwin' and sys_platform != 'linux' and sys_platform != 'win32' and extra == 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra != 'group-13-lightly-train-pinned-torch-minimal'", + "python_full_version >= '3.13' and platform_machine != 's390x' and sys_platform == 'win32' and extra == 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch' and extra != 'group-13-lightly-train-pinned-torch-maximal' and extra != 'group-13-lightly-train-pinned-torch-minimal'", + "python_full_version == '3.12.*' and platform_machine != 's390x' and sys_platform == 'win32' and extra == 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch' and extra != 'group-13-lightly-train-pinned-torch-maximal' and extra != 'group-13-lightly-train-pinned-torch-minimal'", + "python_full_version >= '3.13' and platform_machine != 's390x' and sys_platform == 'darwin' and extra == 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch' and extra != 'group-13-lightly-train-pinned-torch-maximal' and extra != 'group-13-lightly-train-pinned-torch-minimal'", + "python_full_version >= '3.13' and platform_machine == 'aarch64' and sys_platform == 'linux' and extra == 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch' and extra != 'group-13-lightly-train-pinned-torch-maximal' and extra != 'group-13-lightly-train-pinned-torch-minimal'", + "(python_full_version >= '3.13' and platform_machine != 'aarch64' and platform_machine != 's390x' and sys_platform == 'linux' and extra == 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch' and extra != 'group-13-lightly-train-pinned-torch-maximal' and extra != 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.13' and platform_machine != 's390x' and sys_platform != 'darwin' and sys_platform != 'linux' and sys_platform != 'win32' and extra == 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch' and extra != 'group-13-lightly-train-pinned-torch-maximal' and extra != 'group-13-lightly-train-pinned-torch-minimal')", + "python_full_version == '3.12.*' and platform_machine != 's390x' and sys_platform == 'darwin' and extra == 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch' and extra != 'group-13-lightly-train-pinned-torch-maximal' and extra != 'group-13-lightly-train-pinned-torch-minimal'", + "python_full_version == '3.12.*' and platform_machine == 'aarch64' and sys_platform == 'linux' and extra == 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch' and extra != 'group-13-lightly-train-pinned-torch-maximal' and extra != 'group-13-lightly-train-pinned-torch-minimal'", + "(python_full_version == '3.12.*' and platform_machine != 'aarch64' and platform_machine != 's390x' and sys_platform == 'linux' and extra == 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch' and extra != 'group-13-lightly-train-pinned-torch-maximal' and extra != 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version == '3.12.*' and platform_machine != 's390x' and sys_platform != 'darwin' and sys_platform != 'linux' and sys_platform != 'win32' and extra == 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch' and extra != 'group-13-lightly-train-pinned-torch-maximal' and extra != 'group-13-lightly-train-pinned-torch-minimal')", + "python_full_version >= '3.13' and platform_machine == 's390x' and sys_platform == 'win32' and extra == 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch' and extra != 'group-13-lightly-train-pinned-torch-maximal' and extra != 'group-13-lightly-train-pinned-torch-minimal'", + "python_full_version == '3.12.*' and platform_machine == 's390x' and sys_platform == 'win32' and extra == 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch' and extra != 'group-13-lightly-train-pinned-torch-maximal' and extra != 'group-13-lightly-train-pinned-torch-minimal'", + "python_full_version >= '3.13' and platform_machine == 's390x' and sys_platform == 'darwin' and extra == 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch' and extra != 'group-13-lightly-train-pinned-torch-maximal' and extra != 'group-13-lightly-train-pinned-torch-minimal'", + "python_full_version >= '3.13' and platform_machine == 's390x' and sys_platform != 'darwin' and sys_platform != 'win32' and extra == 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch' and extra != 'group-13-lightly-train-pinned-torch-maximal' and extra != 'group-13-lightly-train-pinned-torch-minimal'", + "python_full_version == '3.12.*' and platform_machine == 's390x' and sys_platform == 'darwin' and extra == 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch' and extra != 'group-13-lightly-train-pinned-torch-maximal' and extra != 'group-13-lightly-train-pinned-torch-minimal'", + "python_full_version == '3.12.*' and platform_machine == 's390x' and sys_platform != 'darwin' and sys_platform != 'win32' and extra == 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch' and extra != 'group-13-lightly-train-pinned-torch-maximal' and extra != 'group-13-lightly-train-pinned-torch-minimal'", + "python_full_version == '3.10.*' and sys_platform == 'win32' and extra == 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch' and extra != 'group-13-lightly-train-pinned-torch-maximal' and extra != 'group-13-lightly-train-pinned-torch-minimal'", + "python_full_version == '3.10.*' and platform_machine == 'aarch64' and sys_platform == 'linux' and extra == 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch' and extra != 'group-13-lightly-train-pinned-torch-maximal' and extra != 'group-13-lightly-train-pinned-torch-minimal'", + "python_full_version == '3.10.*' and platform_machine != 'aarch64' and sys_platform == 'linux' and extra == 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch' and extra != 'group-13-lightly-train-pinned-torch-maximal' and extra != 'group-13-lightly-train-pinned-torch-minimal'", + "python_full_version == '3.10.*' and sys_platform == 'darwin' and extra == 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch' and extra != 'group-13-lightly-train-pinned-torch-maximal' and extra != 'group-13-lightly-train-pinned-torch-minimal'", + "python_full_version == '3.10.*' and sys_platform != 'darwin' and sys_platform != 'linux' and sys_platform != 'win32' and extra == 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch' and extra != 'group-13-lightly-train-pinned-torch-maximal' and extra != 'group-13-lightly-train-pinned-torch-minimal'", + "python_full_version >= '3.13' and platform_machine != 's390x' and sys_platform == 'win32' and extra == 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-minimal-torch' and extra != 'group-13-lightly-train-pinned-torch-maximal' and extra != 'group-13-lightly-train-pinned-torch-minimal'", + "python_full_version == '3.12.*' and platform_machine != 's390x' and sys_platform == 'win32' and extra == 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-minimal-torch' and extra != 'group-13-lightly-train-pinned-torch-maximal' and extra != 'group-13-lightly-train-pinned-torch-minimal'", + "python_full_version >= '3.13' and platform_machine != 's390x' and sys_platform == 'darwin' and extra == 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-minimal-torch' and extra != 'group-13-lightly-train-pinned-torch-maximal' and extra != 'group-13-lightly-train-pinned-torch-minimal'", + "python_full_version >= '3.13' and platform_machine == 'aarch64' and sys_platform == 'linux' and extra == 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-minimal-torch' and extra != 'group-13-lightly-train-pinned-torch-maximal' and extra != 'group-13-lightly-train-pinned-torch-minimal'", + "(python_full_version >= '3.13' and platform_machine != 'aarch64' and platform_machine != 's390x' and sys_platform == 'linux' and extra == 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-minimal-torch' and extra != 'group-13-lightly-train-pinned-torch-maximal' and extra != 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.13' and platform_machine != 's390x' and sys_platform != 'darwin' and sys_platform != 'linux' and sys_platform != 'win32' and extra == 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-minimal-torch' and extra != 'group-13-lightly-train-pinned-torch-maximal' and extra != 'group-13-lightly-train-pinned-torch-minimal')", + "python_full_version == '3.12.*' and platform_machine != 's390x' and sys_platform == 'darwin' and extra == 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-minimal-torch' and extra != 'group-13-lightly-train-pinned-torch-maximal' and extra != 'group-13-lightly-train-pinned-torch-minimal'", + "python_full_version == '3.12.*' and platform_machine == 'aarch64' and sys_platform == 'linux' and extra == 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-minimal-torch' and extra != 'group-13-lightly-train-pinned-torch-maximal' and extra != 'group-13-lightly-train-pinned-torch-minimal'", + "(python_full_version == '3.12.*' and platform_machine != 'aarch64' and platform_machine != 's390x' and sys_platform == 'linux' and extra == 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-minimal-torch' and extra != 'group-13-lightly-train-pinned-torch-maximal' and extra != 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version == '3.12.*' and platform_machine != 's390x' and sys_platform != 'darwin' and sys_platform != 'linux' and sys_platform != 'win32' and extra == 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-minimal-torch' and extra != 'group-13-lightly-train-pinned-torch-maximal' and extra != 'group-13-lightly-train-pinned-torch-minimal')", + "python_full_version >= '3.13' and platform_machine == 's390x' and sys_platform == 'win32' and extra == 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-minimal-torch' and extra != 'group-13-lightly-train-pinned-torch-maximal' and extra != 'group-13-lightly-train-pinned-torch-minimal'", + "python_full_version == '3.12.*' and platform_machine == 's390x' and sys_platform == 'win32' and extra == 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-minimal-torch' and extra != 'group-13-lightly-train-pinned-torch-maximal' and extra != 'group-13-lightly-train-pinned-torch-minimal'", + "python_full_version >= '3.13' and platform_machine == 's390x' and sys_platform == 'darwin' and extra == 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-minimal-torch' and extra != 'group-13-lightly-train-pinned-torch-maximal' and extra != 'group-13-lightly-train-pinned-torch-minimal'", + "python_full_version >= '3.13' and platform_machine == 's390x' and sys_platform != 'darwin' and sys_platform != 'win32' and extra == 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-minimal-torch' and extra != 'group-13-lightly-train-pinned-torch-maximal' and extra != 'group-13-lightly-train-pinned-torch-minimal'", + "python_full_version == '3.12.*' and platform_machine == 's390x' and sys_platform == 'darwin' and extra == 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-minimal-torch' and extra != 'group-13-lightly-train-pinned-torch-maximal' and extra != 'group-13-lightly-train-pinned-torch-minimal'", + "python_full_version == '3.12.*' and platform_machine == 's390x' and sys_platform != 'darwin' and sys_platform != 'win32' and extra == 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-minimal-torch' and extra != 'group-13-lightly-train-pinned-torch-maximal' and extra != 'group-13-lightly-train-pinned-torch-minimal'", + "python_full_version == '3.10.*' and sys_platform == 'win32' and extra == 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-minimal-torch' and extra != 'group-13-lightly-train-pinned-torch-maximal' and extra != 'group-13-lightly-train-pinned-torch-minimal'", + "python_full_version == '3.10.*' and platform_machine == 'aarch64' and sys_platform == 'linux' and extra == 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-minimal-torch' and extra != 'group-13-lightly-train-pinned-torch-maximal' and extra != 'group-13-lightly-train-pinned-torch-minimal'", + "python_full_version == '3.10.*' and platform_machine != 'aarch64' and sys_platform == 'linux' and extra == 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-minimal-torch' and extra != 'group-13-lightly-train-pinned-torch-maximal' and extra != 'group-13-lightly-train-pinned-torch-minimal'", + "python_full_version == '3.10.*' and sys_platform == 'darwin' and extra == 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-minimal-torch' and extra != 'group-13-lightly-train-pinned-torch-maximal' and extra != 'group-13-lightly-train-pinned-torch-minimal'", + "python_full_version == '3.10.*' and sys_platform != 'darwin' and sys_platform != 'linux' and sys_platform != 'win32' and extra == 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-minimal-torch' and extra != 'group-13-lightly-train-pinned-torch-maximal' and extra != 'group-13-lightly-train-pinned-torch-minimal'", + "python_full_version >= '3.13' and platform_machine != 's390x' and sys_platform == 'win32' and extra != 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-minimal-torch' and extra != 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal'", + "python_full_version == '3.12.*' and platform_machine != 's390x' and sys_platform == 'win32' and extra != 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-minimal-torch' and extra != 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal'", + "python_full_version >= '3.13' and platform_machine != 's390x' and sys_platform == 'darwin' and extra != 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-minimal-torch' and extra != 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal'", + "python_full_version >= '3.13' and platform_machine == 'aarch64' and sys_platform == 'linux' and extra != 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-minimal-torch' and extra != 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal'", + "(python_full_version >= '3.13' and platform_machine != 'aarch64' and platform_machine != 's390x' and sys_platform == 'linux' and extra != 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-minimal-torch' and extra != 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.13' and platform_machine != 's390x' and sys_platform != 'darwin' and sys_platform != 'linux' and sys_platform != 'win32' and extra != 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-minimal-torch' and extra != 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal')", + "python_full_version == '3.12.*' and platform_machine != 's390x' and sys_platform == 'darwin' and extra != 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-minimal-torch' and extra != 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal'", + "python_full_version == '3.12.*' and platform_machine == 'aarch64' and sys_platform == 'linux' and extra != 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-minimal-torch' and extra != 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal'", + "(python_full_version == '3.12.*' and platform_machine != 'aarch64' and platform_machine != 's390x' and sys_platform == 'linux' and extra != 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-minimal-torch' and extra != 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version == '3.12.*' and platform_machine != 's390x' and sys_platform != 'darwin' and sys_platform != 'linux' and sys_platform != 'win32' and extra != 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-minimal-torch' and extra != 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal')", + "python_full_version >= '3.13' and platform_machine == 's390x' and sys_platform == 'win32' and extra != 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-minimal-torch' and extra != 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal'", + "python_full_version == '3.12.*' and platform_machine == 's390x' and sys_platform == 'win32' and extra != 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-minimal-torch' and extra != 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal'", + "python_full_version >= '3.13' and platform_machine == 's390x' and sys_platform == 'darwin' and extra != 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-minimal-torch' and extra != 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal'", + "python_full_version >= '3.13' and platform_machine == 's390x' and sys_platform != 'darwin' and sys_platform != 'win32' and extra != 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-minimal-torch' and extra != 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal'", + "python_full_version == '3.12.*' and platform_machine == 's390x' and sys_platform == 'darwin' and extra != 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-minimal-torch' and extra != 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal'", + "python_full_version == '3.12.*' and platform_machine == 's390x' and sys_platform != 'darwin' and sys_platform != 'win32' and extra != 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-minimal-torch' and extra != 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal'", + "python_full_version == '3.10.*' and sys_platform == 'win32' and extra != 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-minimal-torch' and extra != 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal'", + "python_full_version == '3.10.*' and platform_machine == 'aarch64' and sys_platform == 'linux' and extra != 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-minimal-torch' and extra != 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal'", + "python_full_version == '3.10.*' and platform_machine != 'aarch64' and sys_platform == 'linux' and extra != 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-minimal-torch' and extra != 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal'", + "python_full_version == '3.10.*' and sys_platform == 'darwin' and extra != 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-minimal-torch' and extra != 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal'", + "python_full_version == '3.10.*' and sys_platform != 'darwin' and sys_platform != 'linux' and sys_platform != 'win32' and extra != 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-minimal-torch' and extra != 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal'", + "python_full_version >= '3.13' and platform_machine != 's390x' and sys_platform == 'win32' and extra != 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra != 'group-13-lightly-train-pinned-torch-minimal'", + "python_full_version == '3.12.*' and platform_machine != 's390x' and sys_platform == 'win32' and extra != 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra != 'group-13-lightly-train-pinned-torch-minimal'", + "python_full_version >= '3.13' and platform_machine != 's390x' and sys_platform == 'darwin' and extra != 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra != 'group-13-lightly-train-pinned-torch-minimal'", + "python_full_version >= '3.13' and platform_machine == 'aarch64' and sys_platform == 'linux' and extra != 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra != 'group-13-lightly-train-pinned-torch-minimal'", + "(python_full_version >= '3.13' and platform_machine != 'aarch64' and platform_machine != 's390x' and sys_platform == 'linux' and extra != 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra != 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.13' and platform_machine != 's390x' and sys_platform != 'darwin' and sys_platform != 'linux' and sys_platform != 'win32' and extra != 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra != 'group-13-lightly-train-pinned-torch-minimal')", + "python_full_version == '3.12.*' and platform_machine != 's390x' and sys_platform == 'darwin' and extra != 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra != 'group-13-lightly-train-pinned-torch-minimal'", + "python_full_version == '3.12.*' and platform_machine == 'aarch64' and sys_platform == 'linux' and extra != 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra != 'group-13-lightly-train-pinned-torch-minimal'", + "(python_full_version == '3.12.*' and platform_machine != 'aarch64' and platform_machine != 's390x' and sys_platform == 'linux' and extra != 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra != 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version == '3.12.*' and platform_machine != 's390x' and sys_platform != 'darwin' and sys_platform != 'linux' and sys_platform != 'win32' and extra != 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra != 'group-13-lightly-train-pinned-torch-minimal')", + "python_full_version >= '3.13' and platform_machine == 's390x' and sys_platform == 'win32' and extra != 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra != 'group-13-lightly-train-pinned-torch-minimal'", + "python_full_version == '3.12.*' and platform_machine == 's390x' and sys_platform == 'win32' and extra != 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra != 'group-13-lightly-train-pinned-torch-minimal'", + "python_full_version >= '3.13' and platform_machine == 's390x' and sys_platform == 'darwin' and extra != 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra != 'group-13-lightly-train-pinned-torch-minimal'", + "python_full_version >= '3.13' and platform_machine == 's390x' and sys_platform != 'darwin' and sys_platform != 'win32' and extra != 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra != 'group-13-lightly-train-pinned-torch-minimal'", + "python_full_version == '3.12.*' and platform_machine == 's390x' and sys_platform == 'darwin' and extra != 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra != 'group-13-lightly-train-pinned-torch-minimal'", + "python_full_version == '3.12.*' and platform_machine == 's390x' and sys_platform != 'darwin' and sys_platform != 'win32' and extra != 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra != 'group-13-lightly-train-pinned-torch-minimal'", + "python_full_version == '3.10.*' and sys_platform == 'win32' and extra != 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra != 'group-13-lightly-train-pinned-torch-minimal'", + "python_full_version == '3.10.*' and platform_machine == 'aarch64' and sys_platform == 'linux' and extra != 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra != 'group-13-lightly-train-pinned-torch-minimal'", + "python_full_version == '3.10.*' and platform_machine != 'aarch64' and sys_platform == 'linux' and extra != 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra != 'group-13-lightly-train-pinned-torch-minimal'", + "python_full_version == '3.10.*' and sys_platform == 'darwin' and extra != 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra != 'group-13-lightly-train-pinned-torch-minimal'", + "python_full_version == '3.10.*' and sys_platform != 'darwin' and sys_platform != 'linux' and sys_platform != 'win32' and extra != 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra != 'group-13-lightly-train-pinned-torch-minimal'", + "python_full_version >= '3.13' and platform_machine != 's390x' and sys_platform == 'win32' and extra != 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch' and extra != 'group-13-lightly-train-pinned-torch-maximal' and extra != 'group-13-lightly-train-pinned-torch-minimal'", + "python_full_version == '3.12.*' and platform_machine != 's390x' and sys_platform == 'win32' and extra != 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch' and extra != 'group-13-lightly-train-pinned-torch-maximal' and extra != 'group-13-lightly-train-pinned-torch-minimal'", + "python_full_version >= '3.13' and platform_machine != 's390x' and sys_platform == 'darwin' and extra != 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch' and extra != 'group-13-lightly-train-pinned-torch-maximal' and extra != 'group-13-lightly-train-pinned-torch-minimal'", + "python_full_version >= '3.13' and platform_machine == 'aarch64' and sys_platform == 'linux' and extra != 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch' and extra != 'group-13-lightly-train-pinned-torch-maximal' and extra != 'group-13-lightly-train-pinned-torch-minimal'", + "(python_full_version >= '3.13' and platform_machine != 'aarch64' and platform_machine != 's390x' and sys_platform == 'linux' and extra != 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch' and extra != 'group-13-lightly-train-pinned-torch-maximal' and extra != 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.13' and platform_machine != 's390x' and sys_platform != 'darwin' and sys_platform != 'linux' and sys_platform != 'win32' and extra != 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch' and extra != 'group-13-lightly-train-pinned-torch-maximal' and extra != 'group-13-lightly-train-pinned-torch-minimal')", + "python_full_version == '3.12.*' and platform_machine != 's390x' and sys_platform == 'darwin' and extra != 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch' and extra != 'group-13-lightly-train-pinned-torch-maximal' and extra != 'group-13-lightly-train-pinned-torch-minimal'", + "python_full_version == '3.12.*' and platform_machine == 'aarch64' and sys_platform == 'linux' and extra != 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch' and extra != 'group-13-lightly-train-pinned-torch-maximal' and extra != 'group-13-lightly-train-pinned-torch-minimal'", + "(python_full_version == '3.12.*' and platform_machine != 'aarch64' and platform_machine != 's390x' and sys_platform == 'linux' and extra != 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch' and extra != 'group-13-lightly-train-pinned-torch-maximal' and extra != 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version == '3.12.*' and platform_machine != 's390x' and sys_platform != 'darwin' and sys_platform != 'linux' and sys_platform != 'win32' and extra != 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch' and extra != 'group-13-lightly-train-pinned-torch-maximal' and extra != 'group-13-lightly-train-pinned-torch-minimal')", + "python_full_version >= '3.13' and platform_machine == 's390x' and sys_platform == 'win32' and extra != 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch' and extra != 'group-13-lightly-train-pinned-torch-maximal' and extra != 'group-13-lightly-train-pinned-torch-minimal'", + "python_full_version == '3.12.*' and platform_machine == 's390x' and sys_platform == 'win32' and extra != 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch' and extra != 'group-13-lightly-train-pinned-torch-maximal' and extra != 'group-13-lightly-train-pinned-torch-minimal'", + "python_full_version >= '3.13' and platform_machine == 's390x' and sys_platform == 'darwin' and extra != 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch' and extra != 'group-13-lightly-train-pinned-torch-maximal' and extra != 'group-13-lightly-train-pinned-torch-minimal'", + "python_full_version >= '3.13' and platform_machine == 's390x' and sys_platform != 'darwin' and sys_platform != 'win32' and extra != 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch' and extra != 'group-13-lightly-train-pinned-torch-maximal' and extra != 'group-13-lightly-train-pinned-torch-minimal'", + "python_full_version == '3.12.*' and platform_machine == 's390x' and sys_platform == 'darwin' and extra != 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch' and extra != 'group-13-lightly-train-pinned-torch-maximal' and extra != 'group-13-lightly-train-pinned-torch-minimal'", + "python_full_version == '3.12.*' and platform_machine == 's390x' and sys_platform != 'darwin' and sys_platform != 'win32' and extra != 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch' and extra != 'group-13-lightly-train-pinned-torch-maximal' and extra != 'group-13-lightly-train-pinned-torch-minimal'", + "python_full_version == '3.10.*' and sys_platform == 'win32' and extra != 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch' and extra != 'group-13-lightly-train-pinned-torch-maximal' and extra != 'group-13-lightly-train-pinned-torch-minimal'", + "python_full_version == '3.10.*' and platform_machine == 'aarch64' and sys_platform == 'linux' and extra != 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch' and extra != 'group-13-lightly-train-pinned-torch-maximal' and extra != 'group-13-lightly-train-pinned-torch-minimal'", + "python_full_version == '3.10.*' and platform_machine != 'aarch64' and sys_platform == 'linux' and extra != 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch' and extra != 'group-13-lightly-train-pinned-torch-maximal' and extra != 'group-13-lightly-train-pinned-torch-minimal'", + "python_full_version == '3.10.*' and sys_platform == 'darwin' and extra != 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch' and extra != 'group-13-lightly-train-pinned-torch-maximal' and extra != 'group-13-lightly-train-pinned-torch-minimal'", + "python_full_version == '3.10.*' and sys_platform != 'darwin' and sys_platform != 'linux' and sys_platform != 'win32' and extra != 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch' and extra != 'group-13-lightly-train-pinned-torch-maximal' and extra != 'group-13-lightly-train-pinned-torch-minimal'", + "python_full_version >= '3.13' and platform_machine != 's390x' and sys_platform == 'win32' and extra != 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-minimal-torch' and extra != 'group-13-lightly-train-pinned-torch-maximal' and extra != 'group-13-lightly-train-pinned-torch-minimal'", + "python_full_version == '3.12.*' and platform_machine != 's390x' and sys_platform == 'win32' and extra != 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-minimal-torch' and extra != 'group-13-lightly-train-pinned-torch-maximal' and extra != 'group-13-lightly-train-pinned-torch-minimal'", + "python_full_version >= '3.13' and platform_machine != 's390x' and sys_platform == 'darwin' and extra != 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-minimal-torch' and extra != 'group-13-lightly-train-pinned-torch-maximal' and extra != 'group-13-lightly-train-pinned-torch-minimal'", + "python_full_version >= '3.13' and platform_machine == 'aarch64' and sys_platform == 'linux' and extra != 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-minimal-torch' and extra != 'group-13-lightly-train-pinned-torch-maximal' and extra != 'group-13-lightly-train-pinned-torch-minimal'", + "(python_full_version >= '3.13' and platform_machine != 'aarch64' and platform_machine != 's390x' and sys_platform == 'linux' and extra != 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-minimal-torch' and extra != 'group-13-lightly-train-pinned-torch-maximal' and extra != 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.13' and platform_machine != 's390x' and sys_platform != 'darwin' and sys_platform != 'linux' and sys_platform != 'win32' and extra != 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-minimal-torch' and extra != 'group-13-lightly-train-pinned-torch-maximal' and extra != 'group-13-lightly-train-pinned-torch-minimal')", + "python_full_version == '3.12.*' and platform_machine != 's390x' and sys_platform == 'darwin' and extra != 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-minimal-torch' and extra != 'group-13-lightly-train-pinned-torch-maximal' and extra != 'group-13-lightly-train-pinned-torch-minimal'", + "python_full_version == '3.12.*' and platform_machine == 'aarch64' and sys_platform == 'linux' and extra != 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-minimal-torch' and extra != 'group-13-lightly-train-pinned-torch-maximal' and extra != 'group-13-lightly-train-pinned-torch-minimal'", + "(python_full_version == '3.12.*' and platform_machine != 'aarch64' and platform_machine != 's390x' and sys_platform == 'linux' and extra != 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-minimal-torch' and extra != 'group-13-lightly-train-pinned-torch-maximal' and extra != 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version == '3.12.*' and platform_machine != 's390x' and sys_platform != 'darwin' and sys_platform != 'linux' and sys_platform != 'win32' and extra != 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-minimal-torch' and extra != 'group-13-lightly-train-pinned-torch-maximal' and extra != 'group-13-lightly-train-pinned-torch-minimal')", + "python_full_version >= '3.13' and platform_machine == 's390x' and sys_platform == 'win32' and extra != 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-minimal-torch' and extra != 'group-13-lightly-train-pinned-torch-maximal' and extra != 'group-13-lightly-train-pinned-torch-minimal'", + "python_full_version == '3.12.*' and platform_machine == 's390x' and sys_platform == 'win32' and extra != 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-minimal-torch' and extra != 'group-13-lightly-train-pinned-torch-maximal' and extra != 'group-13-lightly-train-pinned-torch-minimal'", + "python_full_version >= '3.13' and platform_machine == 's390x' and sys_platform == 'darwin' and extra != 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-minimal-torch' and extra != 'group-13-lightly-train-pinned-torch-maximal' and extra != 'group-13-lightly-train-pinned-torch-minimal'", + "python_full_version >= '3.13' and platform_machine == 's390x' and sys_platform != 'darwin' and sys_platform != 'win32' and extra != 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-minimal-torch' and extra != 'group-13-lightly-train-pinned-torch-maximal' and extra != 'group-13-lightly-train-pinned-torch-minimal'", + "python_full_version == '3.12.*' and platform_machine == 's390x' and sys_platform == 'darwin' and extra != 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-minimal-torch' and extra != 'group-13-lightly-train-pinned-torch-maximal' and extra != 'group-13-lightly-train-pinned-torch-minimal'", + "python_full_version == '3.12.*' and platform_machine == 's390x' and sys_platform != 'darwin' and sys_platform != 'win32' and extra != 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-minimal-torch' and extra != 'group-13-lightly-train-pinned-torch-maximal' and extra != 'group-13-lightly-train-pinned-torch-minimal'", + "python_full_version == '3.10.*' and sys_platform == 'win32' and extra != 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-minimal-torch' and extra != 'group-13-lightly-train-pinned-torch-maximal' and extra != 'group-13-lightly-train-pinned-torch-minimal'", + "python_full_version == '3.10.*' and platform_machine == 'aarch64' and sys_platform == 'linux' and extra != 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-minimal-torch' and extra != 'group-13-lightly-train-pinned-torch-maximal' and extra != 'group-13-lightly-train-pinned-torch-minimal'", + "python_full_version == '3.10.*' and platform_machine != 'aarch64' and sys_platform == 'linux' and extra != 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-minimal-torch' and extra != 'group-13-lightly-train-pinned-torch-maximal' and extra != 'group-13-lightly-train-pinned-torch-minimal'", + "python_full_version == '3.10.*' and sys_platform == 'darwin' and extra != 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-minimal-torch' and extra != 'group-13-lightly-train-pinned-torch-maximal' and extra != 'group-13-lightly-train-pinned-torch-minimal'", + "python_full_version == '3.10.*' and sys_platform != 'darwin' and sys_platform != 'linux' and sys_platform != 'win32' and extra != 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-minimal-torch' and extra != 'group-13-lightly-train-pinned-torch-maximal' and extra != 'group-13-lightly-train-pinned-torch-minimal'", ] dependencies = [ - { name = "numpy", version = "1.23.0", source = { registry = "https://pypi.org/simple" }, marker = "(python_full_version == '3.10.*' and extra == 'extra-13-lightly-train-onnx') or (python_full_version == '3.10.*' and extra == 'extra-13-lightly-train-onnxruntime') or (python_full_version == '3.10.*' and extra == 'extra-13-lightly-train-rfdetr') or (python_full_version == '3.10.*' and extra != 'extra-13-lightly-train-super-gradients') or (python_full_version != '3.10.*' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version != '3.10.*' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version != '3.10.*' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (extra == 'extra-13-lightly-train-onnx' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (extra == 'extra-13-lightly-train-onnx' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (extra == 'extra-13-lightly-train-onnx' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (extra == 'extra-13-lightly-train-onnxruntime' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (extra == 'extra-13-lightly-train-onnxruntime' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (extra == 'extra-13-lightly-train-onnxruntime' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (extra == 'extra-13-lightly-train-rfdetr' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (extra == 'extra-13-lightly-train-rfdetr' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (extra == 'extra-13-lightly-train-rfdetr' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (extra == 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (extra == 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (extra == 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal')" }, + { name = "numpy", version = "1.23.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version == '3.10.*' or (extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal')" }, { name = "numpy", version = "2.4.5", source = { registry = "https://pypi.org/simple" }, marker = "(python_full_version >= '3.12' and extra == 'extra-13-lightly-train-onnx') or (python_full_version >= '3.12' and extra == 'extra-13-lightly-train-onnxruntime') or (python_full_version >= '3.12' and extra == 'extra-13-lightly-train-rfdetr') or (python_full_version >= '3.12' and extra != 'extra-13-lightly-train-super-gradients') or (python_full_version < '3.12' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version < '3.12' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version < '3.12' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (extra == 'extra-13-lightly-train-onnx' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (extra == 'extra-13-lightly-train-onnx' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (extra == 'extra-13-lightly-train-onnx' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (extra == 'extra-13-lightly-train-onnxruntime' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (extra == 'extra-13-lightly-train-onnxruntime' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (extra == 'extra-13-lightly-train-onnxruntime' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (extra == 'extra-13-lightly-train-rfdetr' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (extra == 'extra-13-lightly-train-rfdetr' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (extra == 'extra-13-lightly-train-rfdetr' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (extra == 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (extra == 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (extra == 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal')" }, ] sdist = { url = "https://files.pythonhosted.org/packages/2f/7e/d20f68a5f1487adf19d74378d349932a386b1ece3be9be9915e5986db468/opencv-python-headless-4.10.0.84.tar.gz", hash = "sha256:f2017c6101d7c2ef8d7bc3b414c37ff7f54d64413a1847d89970b6b7069b4e1a", size = 95117755, upload-time = "2024-06-17T18:32:15.606Z" } @@ -46067,8 +46202,8 @@ version = "0.0.4" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "numpy", version = "1.23.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.12' or (extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal')" }, - { name = "opencv-python-headless", version = "4.7.0.72", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version == '3.9.*' or python_full_version == '3.11.*' or (python_full_version == '3.10.*' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version < '3.9' and extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version < '3.9' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version < '3.9' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version < '3.9' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version < '3.9' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version < '3.9' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.12' and extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version >= '3.12' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version >= '3.12' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version >= '3.12' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.12' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.12' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version == '3.10.*' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version == '3.10.*' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version == '3.10.*' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal')" }, - { name = "opencv-python-headless", version = "4.10.0.84", source = { registry = "https://pypi.org/simple" }, marker = "(python_full_version == '3.10.*' and extra == 'extra-13-lightly-train-onnx') or (python_full_version == '3.10.*' and extra == 'extra-13-lightly-train-onnxruntime') or (python_full_version == '3.10.*' and extra == 'extra-13-lightly-train-rfdetr') or (python_full_version == '3.10.*' and extra != 'extra-13-lightly-train-super-gradients') or (python_full_version != '3.10.*' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version != '3.10.*' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version != '3.10.*' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (extra == 'extra-13-lightly-train-onnx' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (extra == 'extra-13-lightly-train-onnx' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (extra == 'extra-13-lightly-train-onnx' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (extra == 'extra-13-lightly-train-onnxruntime' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (extra == 'extra-13-lightly-train-onnxruntime' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (extra == 'extra-13-lightly-train-onnxruntime' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (extra == 'extra-13-lightly-train-rfdetr' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (extra == 'extra-13-lightly-train-rfdetr' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (extra == 'extra-13-lightly-train-rfdetr' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (extra == 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (extra == 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (extra == 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal')" }, + { name = "opencv-python-headless", version = "4.7.0.72", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version == '3.9.*' or python_full_version == '3.11.*' or (python_full_version < '3.9' and extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version < '3.9' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version < '3.9' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version < '3.9' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version < '3.9' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version < '3.9' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version == '3.10.*' and extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version == '3.10.*' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version == '3.10.*' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version == '3.10.*' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version == '3.10.*' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version == '3.10.*' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.12' and extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version >= '3.12' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version >= '3.12' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version >= '3.12' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.12' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.12' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal')" }, + { name = "opencv-python-headless", version = "4.10.0.84", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version == '3.10.*' or (extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal')" }, { name = "opencv-python-headless", version = "4.13.0.92", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.9' or (extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal')" }, { name = "scikit-learn", version = "1.3.2", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.9' or (extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal')" }, { name = "scikit-learn", version = "1.6.1", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version == '3.9.*' or (extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal')" }, @@ -51141,8 +51276,8 @@ resolution-markers = [ "python_full_version == '3.10.*' and platform_machine != 'aarch64' and sys_platform == 'linux' and extra != 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-minimal-torch' and extra != 'group-13-lightly-train-pinned-torch-maximal' and extra != 'group-13-lightly-train-pinned-torch-minimal'", ] dependencies = [ - { name = "cryptography", marker = "(python_full_version >= '3.10' and python_full_version < '3.12' and sys_platform == 'linux') or (python_full_version >= '3.10' and platform_machine != 's390x' and sys_platform == 'linux') or (python_full_version >= '3.12' and platform_machine != 's390x' and sys_platform != 'darwin' and sys_platform != 'linux' and sys_platform != 'win32') or (python_full_version >= '3.12' and platform_machine == 's390x' and sys_platform != 'win32' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version >= '3.12' and platform_machine == 's390x' and sys_platform == 'linux' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version >= '3.12' and platform_machine == 's390x' and sys_platform != 'win32' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.12' and platform_machine == 's390x' and sys_platform != 'win32' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.12' and platform_machine == 's390x' and sys_platform != 'win32' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.12' and platform_machine == 's390x' and sys_platform == 'linux' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.12' and platform_machine == 's390x' and sys_platform == 'linux' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.12' and platform_machine == 's390x' and sys_platform == 'linux' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.12' and sys_platform == 'darwin' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version < '3.12' and sys_platform != 'linux' and extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version < '3.12' and sys_platform != 'linux' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version < '3.12' and sys_platform != 'linux' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version < '3.12' and sys_platform != 'linux' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version < '3.12' and sys_platform != 'linux' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version < '3.12' and sys_platform != 'linux' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version < '3.12' and sys_platform == 'darwin' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version < '3.12' and sys_platform == 'darwin' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version < '3.12' and sys_platform == 'darwin' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version < '3.10' and sys_platform == 'linux' and extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version < '3.10' and sys_platform == 'linux' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version < '3.10' and sys_platform == 'linux' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version < '3.10' and sys_platform == 'linux' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version < '3.10' and sys_platform == 'linux' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version < '3.10' and sys_platform == 'linux' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (sys_platform == 'darwin' and extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (sys_platform == 'darwin' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (sys_platform == 'darwin' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (sys_platform == 'win32' and extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (sys_platform == 'win32' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (sys_platform == 'win32' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (sys_platform == 'win32' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (sys_platform == 'win32' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (sys_platform == 'win32' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (sys_platform == 'darwin' and extra == 'extra-13-lightly-train-onnx' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (sys_platform == 'darwin' and extra == 'extra-13-lightly-train-onnx' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (sys_platform == 'darwin' and extra == 'extra-13-lightly-train-onnx' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (sys_platform == 'darwin' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (sys_platform == 'darwin' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (sys_platform == 'darwin' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (sys_platform == 'darwin' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (sys_platform == 'darwin' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (sys_platform == 'darwin' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (sys_platform == 'darwin' and extra != 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (sys_platform == 'darwin' and extra != 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (sys_platform == 'darwin' and extra != 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal')" }, - { name = "jeepney", marker = "(python_full_version >= '3.10' and python_full_version < '3.12' and sys_platform == 'linux') or (python_full_version >= '3.10' and platform_machine != 's390x' and sys_platform == 'linux') or (python_full_version >= '3.12' and platform_machine != 's390x' and sys_platform != 'darwin' and sys_platform != 'linux' and sys_platform != 'win32') or (python_full_version >= '3.12' and platform_machine == 's390x' and sys_platform != 'win32' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version >= '3.12' and platform_machine == 's390x' and sys_platform == 'linux' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version >= '3.12' and platform_machine == 's390x' and sys_platform != 'win32' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.12' and platform_machine == 's390x' and sys_platform != 'win32' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.12' and platform_machine == 's390x' and sys_platform != 'win32' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.12' and platform_machine == 's390x' and sys_platform == 'linux' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.12' and platform_machine == 's390x' and sys_platform == 'linux' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.12' and platform_machine == 's390x' and sys_platform == 'linux' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.12' and sys_platform == 'darwin' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version < '3.12' and sys_platform != 'linux' and extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version < '3.12' and sys_platform != 'linux' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version < '3.12' and sys_platform != 'linux' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version < '3.12' and sys_platform != 'linux' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version < '3.12' and sys_platform != 'linux' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version < '3.12' and sys_platform != 'linux' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version < '3.12' and sys_platform == 'darwin' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version < '3.12' and sys_platform == 'darwin' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version < '3.12' and sys_platform == 'darwin' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version < '3.10' and sys_platform == 'linux' and extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version < '3.10' and sys_platform == 'linux' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version < '3.10' and sys_platform == 'linux' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version < '3.10' and sys_platform == 'linux' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version < '3.10' and sys_platform == 'linux' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version < '3.10' and sys_platform == 'linux' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (sys_platform == 'darwin' and extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (sys_platform == 'darwin' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (sys_platform == 'darwin' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (sys_platform == 'win32' and extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (sys_platform == 'win32' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (sys_platform == 'win32' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (sys_platform == 'win32' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (sys_platform == 'win32' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (sys_platform == 'win32' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (sys_platform == 'darwin' and extra == 'extra-13-lightly-train-onnx' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (sys_platform == 'darwin' and extra == 'extra-13-lightly-train-onnx' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (sys_platform == 'darwin' and extra == 'extra-13-lightly-train-onnx' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (sys_platform == 'darwin' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (sys_platform == 'darwin' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (sys_platform == 'darwin' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (sys_platform == 'darwin' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (sys_platform == 'darwin' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (sys_platform == 'darwin' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (sys_platform == 'darwin' and extra != 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (sys_platform == 'darwin' and extra != 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (sys_platform == 'darwin' and extra != 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal')" }, + { name = "cryptography", marker = "(python_full_version >= '3.10' and python_full_version < '3.12' and sys_platform == 'linux' and extra == 'extra-13-lightly-train-onnx') or (python_full_version >= '3.10' and python_full_version < '3.12' and sys_platform == 'linux' and extra == 'extra-13-lightly-train-onnxruntime') or (python_full_version >= '3.10' and python_full_version < '3.12' and sys_platform == 'linux' and extra == 'extra-13-lightly-train-rfdetr') or (python_full_version >= '3.10' and python_full_version < '3.12' and sys_platform == 'linux' and extra != 'extra-13-lightly-train-super-gradients') or (python_full_version >= '3.10' and python_full_version < '3.12' and sys_platform == 'linux' and extra == 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch') or (python_full_version >= '3.10' and python_full_version < '3.12' and sys_platform == 'linux' and extra == 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.10' and python_full_version < '3.12' and sys_platform == 'linux' and extra == 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.10' and platform_machine != 's390x' and sys_platform == 'linux') or (python_full_version >= '3.12' and platform_machine != 's390x' and sys_platform != 'darwin' and sys_platform != 'linux' and sys_platform != 'win32') or (python_full_version >= '3.12' and platform_machine != 's390x' and sys_platform == 'darwin' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version < '3.12' and platform_machine != 's390x' and sys_platform != 'linux' and extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version < '3.12' and platform_machine != 's390x' and sys_platform != 'linux' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version < '3.12' and platform_machine != 's390x' and sys_platform != 'linux' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version < '3.12' and platform_machine != 's390x' and sys_platform != 'linux' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version < '3.12' and platform_machine != 's390x' and sys_platform != 'linux' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version < '3.12' and platform_machine != 's390x' and sys_platform != 'linux' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version < '3.10' and platform_machine == 's390x' and extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version < '3.10' and platform_machine == 's390x' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version < '3.10' and platform_machine == 's390x' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version < '3.10' and platform_machine == 's390x' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version < '3.10' and platform_machine == 's390x' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version < '3.10' and platform_machine == 's390x' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.12' and platform_machine == 's390x' and extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version >= '3.12' and platform_machine == 's390x' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version >= '3.12' and platform_machine == 's390x' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version >= '3.12' and platform_machine == 's390x' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.12' and platform_machine == 's390x' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.12' and platform_machine == 's390x' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version < '3.12' and sys_platform == 'darwin' and extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version < '3.12' and sys_platform == 'darwin' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version < '3.12' and sys_platform == 'darwin' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version < '3.12' and sys_platform == 'darwin' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version < '3.12' and sys_platform == 'darwin' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version < '3.12' and sys_platform == 'darwin' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version < '3.10' and sys_platform == 'linux' and extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version < '3.10' and sys_platform == 'linux' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version < '3.10' and sys_platform == 'linux' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version < '3.10' and sys_platform == 'linux' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version < '3.10' and sys_platform == 'linux' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version < '3.10' and sys_platform == 'linux' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (platform_machine == 's390x' and sys_platform != 'linux' and extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (platform_machine == 's390x' and sys_platform != 'linux' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (platform_machine == 's390x' and sys_platform != 'linux' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (platform_machine == 's390x' and sys_platform != 'linux' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (platform_machine == 's390x' and sys_platform != 'linux' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (platform_machine == 's390x' and sys_platform != 'linux' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (platform_machine == 's390x' and sys_platform == 'darwin' and extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (platform_machine == 's390x' and sys_platform == 'darwin' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (platform_machine == 's390x' and sys_platform == 'darwin' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (platform_machine != 's390x' and sys_platform == 'darwin' and extra != 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (platform_machine != 's390x' and sys_platform == 'darwin' and extra != 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (platform_machine != 's390x' and sys_platform == 'darwin' and extra != 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (platform_machine == 's390x' and sys_platform == 'darwin' and extra != 'extra-13-lightly-train-onnx' and extra != 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-rfdetr' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (platform_machine == 's390x' and sys_platform == 'darwin' and extra != 'extra-13-lightly-train-onnx' and extra != 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-rfdetr' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (platform_machine == 's390x' and sys_platform == 'darwin' and extra != 'extra-13-lightly-train-onnx' and extra != 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-rfdetr' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (sys_platform == 'win32' and extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (sys_platform == 'win32' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (sys_platform == 'win32' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (sys_platform == 'win32' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (sys_platform == 'win32' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (sys_platform == 'win32' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (sys_platform == 'darwin' and extra == 'extra-13-lightly-train-onnx' and extra != 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (sys_platform == 'darwin' and extra == 'extra-13-lightly-train-onnx' and extra != 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (sys_platform == 'darwin' and extra == 'extra-13-lightly-train-onnx' and extra != 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (sys_platform == 'darwin' and extra == 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (sys_platform == 'darwin' and extra == 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (sys_platform == 'darwin' and extra == 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (sys_platform == 'darwin' and extra == 'extra-13-lightly-train-rfdetr' and extra != 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (sys_platform == 'darwin' and extra == 'extra-13-lightly-train-rfdetr' and extra != 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (sys_platform == 'darwin' and extra == 'extra-13-lightly-train-rfdetr' and extra != 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal')" }, + { name = "jeepney", marker = "(python_full_version >= '3.10' and python_full_version < '3.12' and sys_platform == 'linux' and extra == 'extra-13-lightly-train-onnx') or (python_full_version >= '3.10' and python_full_version < '3.12' and sys_platform == 'linux' and extra == 'extra-13-lightly-train-onnxruntime') or (python_full_version >= '3.10' and python_full_version < '3.12' and sys_platform == 'linux' and extra == 'extra-13-lightly-train-rfdetr') or (python_full_version >= '3.10' and python_full_version < '3.12' and sys_platform == 'linux' and extra != 'extra-13-lightly-train-super-gradients') or (python_full_version >= '3.10' and python_full_version < '3.12' and sys_platform == 'linux' and extra == 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch') or (python_full_version >= '3.10' and python_full_version < '3.12' and sys_platform == 'linux' and extra == 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.10' and python_full_version < '3.12' and sys_platform == 'linux' and extra == 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.10' and platform_machine != 's390x' and sys_platform == 'linux') or (python_full_version >= '3.12' and platform_machine != 's390x' and sys_platform != 'darwin' and sys_platform != 'linux' and sys_platform != 'win32') or (python_full_version >= '3.12' and platform_machine != 's390x' and sys_platform == 'darwin' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version < '3.12' and platform_machine != 's390x' and sys_platform != 'linux' and extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version < '3.12' and platform_machine != 's390x' and sys_platform != 'linux' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version < '3.12' and platform_machine != 's390x' and sys_platform != 'linux' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version < '3.12' and platform_machine != 's390x' and sys_platform != 'linux' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version < '3.12' and platform_machine != 's390x' and sys_platform != 'linux' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version < '3.12' and platform_machine != 's390x' and sys_platform != 'linux' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version < '3.10' and platform_machine == 's390x' and extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version < '3.10' and platform_machine == 's390x' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version < '3.10' and platform_machine == 's390x' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version < '3.10' and platform_machine == 's390x' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version < '3.10' and platform_machine == 's390x' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version < '3.10' and platform_machine == 's390x' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.12' and platform_machine == 's390x' and extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version >= '3.12' and platform_machine == 's390x' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version >= '3.12' and platform_machine == 's390x' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version >= '3.12' and platform_machine == 's390x' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.12' and platform_machine == 's390x' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.12' and platform_machine == 's390x' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version < '3.12' and sys_platform == 'darwin' and extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version < '3.12' and sys_platform == 'darwin' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version < '3.12' and sys_platform == 'darwin' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version < '3.12' and sys_platform == 'darwin' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version < '3.12' and sys_platform == 'darwin' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version < '3.12' and sys_platform == 'darwin' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version < '3.10' and sys_platform == 'linux' and extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version < '3.10' and sys_platform == 'linux' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version < '3.10' and sys_platform == 'linux' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version < '3.10' and sys_platform == 'linux' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version < '3.10' and sys_platform == 'linux' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version < '3.10' and sys_platform == 'linux' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (platform_machine == 's390x' and sys_platform != 'linux' and extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (platform_machine == 's390x' and sys_platform != 'linux' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (platform_machine == 's390x' and sys_platform != 'linux' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (platform_machine == 's390x' and sys_platform != 'linux' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (platform_machine == 's390x' and sys_platform != 'linux' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (platform_machine == 's390x' and sys_platform != 'linux' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (platform_machine == 's390x' and sys_platform == 'darwin' and extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (platform_machine == 's390x' and sys_platform == 'darwin' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (platform_machine == 's390x' and sys_platform == 'darwin' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (platform_machine != 's390x' and sys_platform == 'darwin' and extra != 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (platform_machine != 's390x' and sys_platform == 'darwin' and extra != 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (platform_machine != 's390x' and sys_platform == 'darwin' and extra != 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (platform_machine == 's390x' and sys_platform == 'darwin' and extra != 'extra-13-lightly-train-onnx' and extra != 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-rfdetr' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (platform_machine == 's390x' and sys_platform == 'darwin' and extra != 'extra-13-lightly-train-onnx' and extra != 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-rfdetr' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (platform_machine == 's390x' and sys_platform == 'darwin' and extra != 'extra-13-lightly-train-onnx' and extra != 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-rfdetr' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (sys_platform == 'win32' and extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (sys_platform == 'win32' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (sys_platform == 'win32' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (sys_platform == 'win32' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (sys_platform == 'win32' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (sys_platform == 'win32' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (sys_platform == 'darwin' and extra == 'extra-13-lightly-train-onnx' and extra != 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (sys_platform == 'darwin' and extra == 'extra-13-lightly-train-onnx' and extra != 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (sys_platform == 'darwin' and extra == 'extra-13-lightly-train-onnx' and extra != 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (sys_platform == 'darwin' and extra == 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (sys_platform == 'darwin' and extra == 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (sys_platform == 'darwin' and extra == 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (sys_platform == 'darwin' and extra == 'extra-13-lightly-train-rfdetr' and extra != 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (sys_platform == 'darwin' and extra == 'extra-13-lightly-train-rfdetr' and extra != 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (sys_platform == 'darwin' and extra == 'extra-13-lightly-train-rfdetr' and extra != 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal')" }, ] sdist = { url = "https://files.pythonhosted.org/packages/1c/03/e834bcd866f2f8a49a85eaff47340affa3bfa391ee9912a952a1faa68c7b/secretstorage-3.5.0.tar.gz", hash = "sha256:f04b8e4689cbce351744d5537bf6b1329c6fc68f91fa666f60a380edddcd11be", size = 19884, upload-time = "2025-11-23T19:02:53.191Z" } wheels = [ @@ -60604,7 +60739,7 @@ resolution-markers = [ "python_full_version < '3.9' and sys_platform == 'linux'", ] dependencies = [ - { name = "filelock", version = "3.16.1", source = { registry = "https://pypi.org/simple" }, marker = "(python_full_version < '3.9' and extra == 'group-13-lightly-train-minimal-torch') or (extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal')" }, + { name = "filelock", version = "3.16.1", source = { registry = "https://pypi.org/simple" }, marker = "(python_full_version < '3.9' and sys_platform == 'linux' and extra == 'group-13-lightly-train-minimal-torch') or (python_full_version >= '3.9' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.9' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (sys_platform != 'linux' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (sys_platform != 'linux' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (sys_platform != 'linux' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (extra != 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal')" }, ] wheels = [ { url = "https://files.pythonhosted.org/packages/4d/22/91a8af421c8a8902dde76e6ef3db01b258af16c53d81e8c0d0dc13900a9e/triton-2.1.0-0-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:66439923a30d5d48399b08a9eae10370f6c261a5ec864a64983bae63152d39d7", size = 89215103, upload-time = "2023-09-01T07:26:13.625Z" }, @@ -60623,7 +60758,7 @@ resolution-markers = [ "python_full_version < '3.9' and sys_platform == 'linux'", ] dependencies = [ - { name = "filelock", version = "3.16.1", source = { registry = "https://pypi.org/simple" }, marker = "(python_full_version < '3.9' and sys_platform != 'win32' and extra != 'group-13-lightly-train-minimal-torch') or (python_full_version < '3.9' and extra == 'extra-13-lightly-train-onnx' and extra != 'group-13-lightly-train-minimal-torch') or (python_full_version < '3.9' and extra == 'extra-13-lightly-train-onnxruntime' and extra != 'group-13-lightly-train-minimal-torch') or (python_full_version < '3.9' and extra == 'extra-13-lightly-train-rfdetr' and extra != 'group-13-lightly-train-minimal-torch') or (python_full_version < '3.9' and extra != 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-minimal-torch') or (python_full_version >= '3.9' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version < '3.9' and extra == 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-minimal-torch' and extra != 'group-13-lightly-train-pinned-torch-maximal') or (extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (extra == 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (extra == 'extra-13-lightly-train-onnx' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (extra == 'extra-13-lightly-train-onnxruntime' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (extra == 'extra-13-lightly-train-rfdetr' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal')" }, + { name = "filelock", version = "3.16.1", source = { registry = "https://pypi.org/simple" }, marker = "(python_full_version < '3.9' and sys_platform == 'linux' and extra != 'group-13-lightly-train-minimal-torch') or (python_full_version >= '3.9' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (sys_platform != 'linux' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal')" }, ] wheels = [ { url = "https://files.pythonhosted.org/packages/45/27/14cc3101409b9b4b9241d2ba7deaa93535a217a211c86c4cc7151fb12181/triton-3.0.0-1-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:e1efef76935b2febc365bfadf74bcb65a6f959a9872e5bddf44cc9e0adce1e1a", size = 209376304, upload-time = "2024-07-19T20:56:41.483Z" }, @@ -60655,7 +60790,7 @@ resolution-markers = [ "python_full_version == '3.9.*' and platform_machine != 'aarch64' and sys_platform == 'linux' and extra != 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra != 'group-13-lightly-train-pinned-torch-minimal'", ] dependencies = [ - { name = "setuptools", version = "81.0.0", source = { registry = "https://pypi.org/simple" }, marker = "(python_full_version >= '3.9' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal')" }, + { name = "setuptools", version = "81.0.0", source = { registry = "https://pypi.org/simple" }, marker = "(python_full_version >= '3.9' and python_full_version < '3.12' and platform_machine == 's390x' and sys_platform == 'linux' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.9' and platform_machine != 'aarch64' and platform_machine != 's390x' and sys_platform == 'linux' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.12' and platform_machine != 's390x' and sys_platform != 'darwin' and sys_platform != 'linux' and sys_platform != 'win32' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version < '3.12' and platform_machine != 's390x' and sys_platform != 'linux' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version < '3.12' and platform_machine != 's390x' and sys_platform != 'linux' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version < '3.12' and platform_machine != 's390x' and sys_platform != 'linux' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.12' and platform_machine != 's390x' and sys_platform == 'darwin' and extra == 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.12' and platform_machine == 'aarch64' and sys_platform == 'linux' and extra == 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version < '3.9' and platform_machine != 'aarch64' and sys_platform == 'linux' and extra == 'extra-13-lightly-train-onnx' and extra != 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version < '3.9' and platform_machine != 'aarch64' and sys_platform == 'linux' and extra == 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version < '3.9' and platform_machine != 'aarch64' and sys_platform == 'linux' and extra == 'extra-13-lightly-train-rfdetr' and extra != 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version < '3.9' and platform_machine != 'aarch64' and sys_platform == 'linux' and extra != 'extra-13-lightly-train-onnx' and extra != 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-rfdetr' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version < '3.9' and platform_machine != 'aarch64' and sys_platform == 'linux' and extra != 'extra-13-lightly-train-onnx' and extra != 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-rfdetr' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version < '3.9' and platform_machine != 'aarch64' and sys_platform == 'linux' and extra != 'extra-13-lightly-train-onnx' and extra != 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-rfdetr' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version < '3.12' and platform_machine == 'aarch64' and sys_platform == 'linux' and extra != 'extra-13-lightly-train-onnx' and extra != 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-rfdetr' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version < '3.9' and platform_machine == 's390x' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.12' and platform_machine == 's390x' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version < '3.12' and sys_platform == 'darwin' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (platform_machine != 'aarch64' and platform_machine != 's390x' and sys_platform == 'linux' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (platform_machine != 'aarch64' and platform_machine != 's390x' and sys_platform == 'linux' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (platform_machine != 'aarch64' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (platform_machine != 'aarch64' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (platform_machine != 'aarch64' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (platform_machine != 'aarch64' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-onnx' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (platform_machine != 'aarch64' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-onnx' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (platform_machine != 'aarch64' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (platform_machine != 'aarch64' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (platform_machine != 'aarch64' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (platform_machine != 'aarch64' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (platform_machine != 's390x' and sys_platform != 'darwin' and sys_platform != 'linux' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (platform_machine != 's390x' and sys_platform != 'darwin' and sys_platform != 'linux' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (platform_machine == 's390x' and sys_platform != 'linux' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (platform_machine == 's390x' and sys_platform == 'darwin' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (platform_machine == 'aarch64' and sys_platform == 'linux' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (platform_machine == 'aarch64' and sys_platform == 'linux' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (platform_machine == 'aarch64' and sys_platform == 'linux' and extra == 'extra-13-lightly-train-onnx' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (platform_machine == 'aarch64' and sys_platform == 'linux' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (platform_machine == 'aarch64' and sys_platform == 'linux' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (platform_machine == 'aarch64' and sys_platform == 'linux' and extra != 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (platform_machine == 'aarch64' and extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (platform_machine == 'aarch64' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (platform_machine == 'aarch64' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (platform_machine == 's390x' and extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (platform_machine == 's390x' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (platform_machine == 's390x' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (platform_machine == 's390x' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (platform_machine == 's390x' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (platform_machine == 'aarch64' and extra == 'extra-13-lightly-train-onnx' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (platform_machine == 'aarch64' and extra == 'extra-13-lightly-train-onnx' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (platform_machine == 'aarch64' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (platform_machine == 'aarch64' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (platform_machine == 'aarch64' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (platform_machine == 'aarch64' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (sys_platform != 'linux' and extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (sys_platform != 'linux' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (sys_platform != 'linux' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (sys_platform == 'darwin' and extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (sys_platform == 'darwin' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (sys_platform == 'darwin' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (sys_platform == 'darwin' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (sys_platform == 'darwin' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (sys_platform == 'win32' and extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (sys_platform == 'win32' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (sys_platform == 'win32' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (sys_platform == 'win32' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (sys_platform == 'win32' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (sys_platform == 'win32' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (sys_platform != 'linux' and extra == 'extra-13-lightly-train-onnx' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (sys_platform != 'linux' and extra == 'extra-13-lightly-train-onnx' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (sys_platform != 'linux' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (sys_platform != 'linux' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (sys_platform != 'linux' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (sys_platform != 'linux' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (sys_platform == 'darwin' and extra == 'extra-13-lightly-train-onnx' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (sys_platform == 'darwin' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (sys_platform == 'darwin' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (sys_platform == 'darwin' and extra != 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal')" }, ] wheels = [ { url = "https://files.pythonhosted.org/packages/76/04/d54d3a6d077c646624dc9461b0059e23fd5d30e0dbe67471e3654aec81f9/triton-3.3.0-cp310-cp310-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:fad99beafc860501d7fcc1fb7045d9496cbe2c882b1674640304949165a916e7", size = 156441993, upload-time = "2025-04-09T20:27:25.107Z" }, @@ -60676,8 +60811,8 @@ resolution-markers = [ "(python_full_version == '3.12.*' and platform_machine != 'aarch64' and platform_machine != 's390x' and sys_platform == 'linux') or (python_full_version == '3.12.*' and platform_machine != 's390x' and sys_platform != 'darwin' and sys_platform != 'linux' and sys_platform != 'win32')", ] dependencies = [ - { name = "importlib-metadata", version = "8.7.1", source = { registry = "https://pypi.org/simple" }, marker = "(python_full_version == '3.9.*' and extra == 'group-13-lightly-train-minimal-torch') or (python_full_version == '3.9.*' and extra != 'group-13-lightly-train-pinned-torch-maximal') or (extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal')" }, - { name = "setuptools", version = "81.0.0", source = { registry = "https://pypi.org/simple" }, marker = "(python_full_version >= '3.10' and python_full_version < '3.12' and platform_machine != 's390x' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.10' and python_full_version < '3.12' and platform_machine != 's390x' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.10' and python_full_version < '3.12' and platform_machine != 's390x' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version < '3.9' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version < '3.9' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version < '3.9' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version < '3.9' and platform_machine != 's390x' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version < '3.9' and platform_machine != 's390x' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version < '3.9' and platform_machine != 's390x' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.10' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version >= '3.10' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version >= '3.10' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version >= '3.12' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version >= '3.12' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-onnx' and extra == 'group-13-lightly-train-minimal-torch') or (python_full_version >= '3.12' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-onnx' and extra != 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.12' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version >= '3.12' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'group-13-lightly-train-minimal-torch') or (python_full_version >= '3.12' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-onnxruntime' and extra != 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.12' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version >= '3.12' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'group-13-lightly-train-minimal-torch') or (python_full_version >= '3.12' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-rfdetr' and extra != 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.12' and platform_machine != 's390x' and extra != 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch') or (python_full_version >= '3.12' and platform_machine != 's390x' and extra != 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.10' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-onnx' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.10' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-onnx' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.10' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-onnx' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.10' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.10' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.10' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.10' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.10' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.10' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.12' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-onnx' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.12' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.12' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.12' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.12' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.12' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.12' and platform_machine != 's390x' and extra != 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version == '3.9.*' and extra == 'group-13-lightly-train-minimal-torch') or (python_full_version == '3.9.*' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version == '3.9.*' and extra != 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version == '3.9.*' and extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version == '3.9.*' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version == '3.9.*' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (platform_machine == 's390x' and extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (platform_machine == 's390x' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (platform_machine == 's390x' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (platform_machine == 's390x' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (platform_machine == 's390x' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (platform_machine == 's390x' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal')" }, + { name = "importlib-metadata", version = "8.7.1", source = { registry = "https://pypi.org/simple" }, marker = "(python_full_version == '3.9.*' and platform_machine != 'aarch64' and sys_platform == 'linux' and extra == 'group-13-lightly-train-minimal-torch') or (python_full_version == '3.9.*' and platform_machine != 'aarch64' and sys_platform == 'linux' and extra != 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version != '3.9.*' and platform_machine != 'aarch64' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version != '3.9.*' and platform_machine != 'aarch64' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version != '3.9.*' and platform_machine != 'aarch64' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (platform_machine == 'aarch64' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (platform_machine == 'aarch64' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (sys_platform != 'linux' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (sys_platform != 'linux' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (sys_platform != 'linux' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (extra != 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal')" }, + { name = "setuptools", version = "81.0.0", source = { registry = "https://pypi.org/simple" }, marker = "(python_full_version >= '3.10' and python_full_version < '3.12' and platform_machine != 'aarch64' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version >= '3.10' and python_full_version < '3.12' and platform_machine != 'aarch64' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version >= '3.10' and python_full_version < '3.12' and platform_machine != 'aarch64' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version >= '3.10' and python_full_version < '3.12' and platform_machine != 'aarch64' and platform_machine != 's390x' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.10' and python_full_version < '3.12' and platform_machine != 'aarch64' and platform_machine != 's390x' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.10' and python_full_version < '3.12' and platform_machine != 'aarch64' and platform_machine != 's390x' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.12' and platform_machine != 'aarch64' and platform_machine != 's390x' and sys_platform == 'linux' and extra == 'extra-13-lightly-train-onnx' and extra == 'group-13-lightly-train-minimal-torch') or (python_full_version >= '3.12' and platform_machine != 'aarch64' and platform_machine != 's390x' and sys_platform == 'linux' and extra == 'extra-13-lightly-train-onnx' and extra != 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.12' and platform_machine != 'aarch64' and platform_machine != 's390x' and sys_platform == 'linux' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'group-13-lightly-train-minimal-torch') or (python_full_version >= '3.12' and platform_machine != 'aarch64' and platform_machine != 's390x' and sys_platform == 'linux' and extra == 'extra-13-lightly-train-onnxruntime' and extra != 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.12' and platform_machine != 'aarch64' and platform_machine != 's390x' and sys_platform == 'linux' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'group-13-lightly-train-minimal-torch') or (python_full_version >= '3.12' and platform_machine != 'aarch64' and platform_machine != 's390x' and sys_platform == 'linux' and extra == 'extra-13-lightly-train-rfdetr' and extra != 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.12' and platform_machine != 'aarch64' and platform_machine != 's390x' and sys_platform == 'linux' and extra != 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch') or (python_full_version >= '3.12' and platform_machine != 'aarch64' and platform_machine != 's390x' and sys_platform == 'linux' and extra != 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version < '3.9' and platform_machine != 'aarch64' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version < '3.9' and platform_machine != 'aarch64' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version < '3.9' and platform_machine != 'aarch64' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version == '3.9.*' and platform_machine != 'aarch64' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version == '3.9.*' and platform_machine != 'aarch64' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version == '3.9.*' and platform_machine != 'aarch64' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version >= '3.12' and platform_machine != 'aarch64' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version >= '3.12' and platform_machine != 'aarch64' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version >= '3.12' and platform_machine != 'aarch64' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (python_full_version < '3.9' and platform_machine != 'aarch64' and platform_machine != 's390x' and extra != 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version == '3.9.*' and platform_machine != 'aarch64' and platform_machine != 's390x' and extra != 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.12' and platform_machine != 'aarch64' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.12' and platform_machine != 'aarch64' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.12' and platform_machine != 'aarch64' and platform_machine != 's390x' and extra == 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.12' and platform_machine != 'aarch64' and platform_machine != 's390x' and extra != 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version >= '3.12' and platform_machine != 's390x' and sys_platform != 'darwin' and sys_platform != 'linux' and sys_platform != 'win32' and extra == 'extra-13-lightly-train-onnx' and extra == 'group-13-lightly-train-minimal-torch') or (python_full_version >= '3.12' and platform_machine != 's390x' and sys_platform != 'darwin' and sys_platform != 'linux' and sys_platform != 'win32' and extra == 'extra-13-lightly-train-onnx' and extra != 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.12' and platform_machine != 's390x' and sys_platform != 'darwin' and sys_platform != 'linux' and sys_platform != 'win32' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'group-13-lightly-train-minimal-torch') or (python_full_version >= '3.12' and platform_machine != 's390x' and sys_platform != 'darwin' and sys_platform != 'linux' and sys_platform != 'win32' and extra == 'extra-13-lightly-train-onnxruntime' and extra != 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.12' and platform_machine != 's390x' and sys_platform != 'darwin' and sys_platform != 'linux' and sys_platform != 'win32' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'group-13-lightly-train-minimal-torch') or (python_full_version >= '3.12' and platform_machine != 's390x' and sys_platform != 'darwin' and sys_platform != 'linux' and sys_platform != 'win32' and extra == 'extra-13-lightly-train-rfdetr' and extra != 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version >= '3.12' and platform_machine != 's390x' and sys_platform != 'darwin' and sys_platform != 'linux' and sys_platform != 'win32' and extra != 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch') or (python_full_version >= '3.12' and platform_machine != 's390x' and sys_platform != 'darwin' and sys_platform != 'linux' and sys_platform != 'win32' and extra != 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version == '3.9.*' and platform_machine == 's390x' and sys_platform == 'linux' and extra == 'group-13-lightly-train-minimal-torch') or (python_full_version == '3.9.*' and platform_machine == 's390x' and sys_platform == 'linux' and extra != 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version < '3.12' and platform_machine != 's390x' and sys_platform != 'linux' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version < '3.12' and platform_machine != 's390x' and sys_platform != 'linux' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version < '3.12' and platform_machine != 's390x' and sys_platform != 'linux' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version == '3.9.*' and platform_machine != 'aarch64' and sys_platform == 'linux' and extra == 'extra-13-lightly-train-onnx' and extra != 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch') or (python_full_version == '3.9.*' and platform_machine != 'aarch64' and sys_platform == 'linux' and extra == 'extra-13-lightly-train-onnx' and extra != 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version == '3.9.*' and platform_machine != 'aarch64' and sys_platform == 'linux' and extra == 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch') or (python_full_version == '3.9.*' and platform_machine != 'aarch64' and sys_platform == 'linux' and extra == 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version == '3.9.*' and platform_machine != 'aarch64' and sys_platform == 'linux' and extra == 'extra-13-lightly-train-rfdetr' and extra != 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch') or (python_full_version == '3.9.*' and platform_machine != 'aarch64' and sys_platform == 'linux' and extra == 'extra-13-lightly-train-rfdetr' and extra != 'extra-13-lightly-train-super-gradients' and extra != 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version < '3.9' and platform_machine != 's390x' and sys_platform == 'linux' and extra == 'extra-13-lightly-train-onnx' and extra != 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version < '3.9' and platform_machine != 's390x' and sys_platform == 'linux' and extra == 'extra-13-lightly-train-onnx' and extra != 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version < '3.9' and platform_machine != 's390x' and sys_platform == 'linux' and extra == 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version < '3.9' and platform_machine != 's390x' and sys_platform == 'linux' and extra == 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version < '3.9' and platform_machine != 's390x' and sys_platform == 'linux' and extra == 'extra-13-lightly-train-rfdetr' and extra != 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version < '3.9' and platform_machine != 's390x' and sys_platform == 'linux' and extra == 'extra-13-lightly-train-rfdetr' and extra != 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version == '3.9.*' and platform_machine != 'aarch64' and sys_platform == 'linux' and extra != 'extra-13-lightly-train-onnx' and extra != 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-rfdetr' and extra == 'group-13-lightly-train-minimal-torch') or (python_full_version == '3.9.*' and platform_machine != 'aarch64' and sys_platform == 'linux' and extra != 'extra-13-lightly-train-onnx' and extra != 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-rfdetr' and extra != 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version < '3.9' and platform_machine != 's390x' and sys_platform == 'linux' and extra != 'extra-13-lightly-train-onnx' and extra != 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-rfdetr' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version < '3.9' and platform_machine != 's390x' and sys_platform == 'linux' and extra != 'extra-13-lightly-train-onnx' and extra != 'extra-13-lightly-train-onnxruntime' and extra != 'extra-13-lightly-train-rfdetr' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version != '3.9.*' and platform_machine == 's390x' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (python_full_version != '3.9.*' and platform_machine == 's390x' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (python_full_version != '3.9.*' and platform_machine == 's390x' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (platform_machine == 's390x' and sys_platform != 'linux' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (platform_machine == 's390x' and sys_platform != 'linux' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (platform_machine == 'aarch64' and sys_platform == 'linux' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (platform_machine == 'aarch64' and sys_platform == 'linux' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (platform_machine != 's390x' and sys_platform != 'linux' and extra == 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (platform_machine != 's390x' and sys_platform != 'linux' and extra == 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (platform_machine != 's390x' and sys_platform != 'linux' and extra == 'extra-13-lightly-train-super-gradients' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (platform_machine == 'aarch64' and extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (platform_machine == 'aarch64' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (platform_machine == 'aarch64' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (platform_machine == 's390x' and extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (platform_machine == 's390x' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (platform_machine == 's390x' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (platform_machine == 'aarch64' and extra != 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (platform_machine == 's390x' and extra != 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (sys_platform != 'linux' and extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (sys_platform != 'linux' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (sys_platform != 'linux' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (sys_platform == 'darwin' and extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (sys_platform == 'darwin' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (sys_platform == 'darwin' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (sys_platform == 'darwin' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (sys_platform == 'darwin' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (sys_platform == 'darwin' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (sys_platform == 'win32' and extra == 'extra-13-lightly-train-onnx' and extra == 'extra-13-lightly-train-super-gradients') or (sys_platform == 'win32' and extra == 'extra-13-lightly-train-onnxruntime' and extra == 'extra-13-lightly-train-super-gradients') or (sys_platform == 'win32' and extra == 'extra-13-lightly-train-rfdetr' and extra == 'extra-13-lightly-train-super-gradients') or (sys_platform == 'win32' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal') or (sys_platform == 'win32' and extra == 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (sys_platform == 'win32' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal') or (sys_platform != 'linux' and extra != 'group-13-lightly-train-minimal-torch' and extra == 'group-13-lightly-train-pinned-torch-maximal' and extra == 'group-13-lightly-train-pinned-torch-minimal')" }, ] wheels = [ { url = "https://files.pythonhosted.org/packages/62/ee/0ee5f64a87eeda19bbad9bc54ae5ca5b98186ed00055281fd40fb4beb10e/triton-3.4.0-cp310-cp310-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:7ff2785de9bc02f500e085420273bb5cc9c9bb767584a4aa28d6e360cec70128", size = 155430069, upload-time = "2025-07-30T19:58:21.715Z" },