diff --git a/.gitattributes b/.gitattributes new file mode 100644 index 0000000000000000000000000000000000000000..80fba6f19d72211ffb86539538fb2e754b53f9a4 --- /dev/null +++ b/.gitattributes @@ -0,0 +1,71 @@ +*.7z filter=lfs diff=lfs merge=lfs -text +*.arrow filter=lfs diff=lfs merge=lfs -text +*.bin filter=lfs diff=lfs merge=lfs -text +*.bz2 filter=lfs diff=lfs merge=lfs -text +*.ckpt filter=lfs diff=lfs merge=lfs -text +*.ftz filter=lfs diff=lfs merge=lfs -text +*.gz filter=lfs diff=lfs merge=lfs -text +*.h5 filter=lfs diff=lfs merge=lfs -text +*.joblib filter=lfs diff=lfs merge=lfs -text +*.lfs.* filter=lfs diff=lfs merge=lfs -text +*.mlmodel filter=lfs diff=lfs merge=lfs -text +*.model filter=lfs diff=lfs merge=lfs -text +*.msgpack filter=lfs diff=lfs merge=lfs -text +*.npy filter=lfs diff=lfs merge=lfs -text +*.npz filter=lfs diff=lfs merge=lfs -text +*.onnx filter=lfs diff=lfs merge=lfs -text +*.ot filter=lfs diff=lfs merge=lfs -text +*.parquet filter=lfs diff=lfs merge=lfs -text +*.pb filter=lfs diff=lfs merge=lfs -text +*.pickle filter=lfs diff=lfs merge=lfs -text +*.pkl filter=lfs diff=lfs merge=lfs -text +*.pt filter=lfs diff=lfs merge=lfs -text +*.pth filter=lfs diff=lfs merge=lfs -text +*.rar filter=lfs diff=lfs merge=lfs -text +*.safetensors filter=lfs diff=lfs merge=lfs -text +saved_model/**/* filter=lfs diff=lfs merge=lfs -text +*.tar.* filter=lfs diff=lfs merge=lfs -text +*.tar filter=lfs diff=lfs merge=lfs -text +*.tflite filter=lfs diff=lfs merge=lfs -text +*.tgz filter=lfs diff=lfs merge=lfs -text +*.wasm filter=lfs diff=lfs merge=lfs -text +*.xz filter=lfs diff=lfs merge=lfs -text +*.zip filter=lfs diff=lfs merge=lfs -text +*.zst filter=lfs diff=lfs merge=lfs -text +*tfevents* filter=lfs diff=lfs merge=lfs -text +build/torch210-cxx11-cu126-x86_64-linux/_cv_utils_8541a33.abi3.so filter=lfs diff=lfs merge=lfs -text +build/torch210-cxx11-cu128-x86_64-linux/_cv_utils_8541a33.abi3.so filter=lfs diff=lfs merge=lfs -text +build/torch210-cxx11-cu130-x86_64-linux/_cv_utils_8541a33.abi3.so filter=lfs diff=lfs merge=lfs -text +build/torch28-cxx11-cu126-x86_64-linux/_cv_utils_8541a33.abi3.so filter=lfs diff=lfs merge=lfs -text +build/torch28-cxx11-cu128-x86_64-linux/_cv_utils_8541a33.abi3.so filter=lfs diff=lfs merge=lfs -text +build/torch28-cxx11-cu129-x86_64-linux/_cv_utils_8541a33.abi3.so filter=lfs diff=lfs merge=lfs -text +build/torch29-cxx11-cu126-x86_64-linux/_cv_utils_8541a33.abi3.so filter=lfs diff=lfs merge=lfs -text +build/torch29-cxx11-cu128-x86_64-linux/_cv_utils_8541a33.abi3.so filter=lfs diff=lfs merge=lfs -text +build/torch29-cxx11-cu130-x86_64-linux/_cv_utils_8541a33.abi3.so filter=lfs diff=lfs merge=lfs -text +build/torch210-cxx11-cu126-aarch64-linux/_cv_utils_cuda_8cfc281.abi3.so filter=lfs diff=lfs merge=lfs -text +build/torch210-cxx11-cu128-aarch64-linux/_cv_utils_cuda_8cfc281.abi3.so filter=lfs diff=lfs merge=lfs -text +build/torch210-cxx11-cu130-aarch64-linux/_cv_utils_cuda_8cfc281.abi3.so filter=lfs diff=lfs merge=lfs -text +build/torch29-cxx11-cu126-aarch64-linux/_cv_utils_cuda_8cfc281.abi3.so filter=lfs diff=lfs merge=lfs -text +build/torch29-cxx11-cu128-aarch64-linux/_cv_utils_cuda_8cfc281.abi3.so filter=lfs diff=lfs merge=lfs -text +build/torch29-cxx11-cu130-aarch64-linux/_cv_utils_cuda_8cfc281.abi3.so filter=lfs diff=lfs merge=lfs -text +build/torch210-cxx11-cu126-x86_64-linux/_cv_utils_cuda_8cfc281.abi3.so filter=lfs diff=lfs merge=lfs -text +build/torch210-cxx11-cu128-x86_64-linux/_cv_utils_cuda_8cfc281.abi3.so filter=lfs diff=lfs merge=lfs -text +build/torch210-cxx11-cu130-x86_64-linux/_cv_utils_cuda_8cfc281.abi3.so filter=lfs diff=lfs merge=lfs -text +build/torch29-cxx11-cu126-x86_64-linux/_cv_utils_cuda_8cfc281.abi3.so filter=lfs diff=lfs merge=lfs -text +build/torch29-cxx11-cu128-x86_64-linux/_cv_utils_cuda_8cfc281.abi3.so filter=lfs diff=lfs merge=lfs -text +build/torch29-cxx11-cu130-x86_64-linux/_cv_utils_cuda_8cfc281.abi3.so filter=lfs diff=lfs merge=lfs -text +build/torch210-cu128-x86_64-windows/_cv_utils_cuda_0561e14.pyd filter=lfs diff=lfs merge=lfs -text +build/torch210-cxx11-cu126-aarch64-linux/_cv_utils_cuda_d91fc8d.abi3.so filter=lfs diff=lfs merge=lfs -text +build/torch210-cxx11-cu128-aarch64-linux/_cv_utils_cuda_d91fc8d.abi3.so filter=lfs diff=lfs merge=lfs -text +build/torch210-cxx11-cu130-aarch64-linux/_cv_utils_cuda_d91fc8d.abi3.so filter=lfs diff=lfs merge=lfs -text +build/torch211-cxx11-cu126-aarch64-linux/_cv_utils_cuda_d91fc8d.abi3.so filter=lfs diff=lfs merge=lfs -text +build/torch211-cxx11-cu128-aarch64-linux/_cv_utils_cuda_d91fc8d.abi3.so filter=lfs diff=lfs merge=lfs -text +build/torch211-cxx11-cu130-aarch64-linux/_cv_utils_cuda_d91fc8d.abi3.so filter=lfs diff=lfs merge=lfs -text +build/torch29-cxx11-cu129-aarch64-linux/_cv_utils_cuda_d91fc8d.abi3.so filter=lfs diff=lfs merge=lfs -text +build/torch210-cxx11-cu126-x86_64-linux/_cv_utils_cuda_d91fc8d.abi3.so filter=lfs diff=lfs merge=lfs -text +build/torch210-cxx11-cu128-x86_64-linux/_cv_utils_cuda_d91fc8d.abi3.so filter=lfs diff=lfs merge=lfs -text +build/torch210-cxx11-cu130-x86_64-linux/_cv_utils_cuda_d91fc8d.abi3.so filter=lfs diff=lfs merge=lfs -text +build/torch211-cxx11-cu126-x86_64-linux/_cv_utils_cuda_d91fc8d.abi3.so filter=lfs diff=lfs merge=lfs -text +build/torch211-cxx11-cu128-x86_64-linux/_cv_utils_cuda_d91fc8d.abi3.so filter=lfs diff=lfs merge=lfs -text +build/torch211-cxx11-cu130-x86_64-linux/_cv_utils_cuda_d91fc8d.abi3.so filter=lfs diff=lfs merge=lfs -text +build/torch29-cxx11-cu129-x86_64-linux/_cv_utils_cuda_d91fc8d.abi3.so filter=lfs diff=lfs merge=lfs -text diff --git a/build/torch210-cu128-x86_64-windows/__init__.py b/build/torch210-cu128-x86_64-windows/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..ce3c6dabc35475ff9d2195ece05ad683d42f458a --- /dev/null +++ b/build/torch210-cu128-x86_64-windows/__init__.py @@ -0,0 +1,12 @@ +import torch +from typing import List + +from ._ops import ops + +def cc_2d(inputs: torch.Tensor, get_counts: bool) -> List[torch.Tensor]: + return ops.cc_2d(inputs, get_counts) + +def generic_nms(dets: torch.Tensor, scores: torch.Tensor, iou_threshold: float, use_iou_matrix: bool) -> torch.Tensor: + return ops.generic_nms(dets, scores, iou_threshold, use_iou_matrix) + +__all__ = ["cc_2d", "generic_nms"] \ No newline at end of file diff --git a/build/torch210-cu128-x86_64-windows/_cv_utils_cuda_0561e14.pyd b/build/torch210-cu128-x86_64-windows/_cv_utils_cuda_0561e14.pyd new file mode 100644 index 0000000000000000000000000000000000000000..c2f90f4047d47fa9263258766783f2ddf40e3c6b --- /dev/null +++ b/build/torch210-cu128-x86_64-windows/_cv_utils_cuda_0561e14.pyd @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:421b973a2ce02fe068ac5015ebb50d55a46abdb1f5eceb9f3dbc32383505be5b +size 1782784 diff --git a/build/torch210-cu128-x86_64-windows/_ops.py b/build/torch210-cu128-x86_64-windows/_ops.py new file mode 100644 index 0000000000000000000000000000000000000000..7512e456fcd42a9fd9be5bb85bd1821d4331083c --- /dev/null +++ b/build/torch210-cu128-x86_64-windows/_ops.py @@ -0,0 +1,9 @@ +import torch +from . import _cv_utils_cuda_0561e14 +ops = torch.ops._cv_utils_cuda_0561e14 + +def add_op_namespace_prefix(op_name: str): + """ + Prefix op by namespace. + """ + return f"_cv_utils_cuda_0561e14::{op_name}" diff --git a/build/torch210-cu128-x86_64-windows/cv_utils/__init__.py b/build/torch210-cu128-x86_64-windows/cv_utils/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..bc434ef44e63409acb52a8f3fff54a4adc46ed6a --- /dev/null +++ b/build/torch210-cu128-x86_64-windows/cv_utils/__init__.py @@ -0,0 +1,26 @@ +import ctypes +import sys + +import importlib +from pathlib import Path +from types import ModuleType + +def _import_from_path(file_path: Path) -> ModuleType: + # We cannot use the module name as-is, after adding it to `sys.modules`, + # it would also be used for other imports. So, we make a module name that + # depends on the path for it to be unique using the hex-encoded hash of + # the path. + path_hash = "{:x}".format(ctypes.c_size_t(hash(file_path.absolute())).value) + module_name = path_hash + spec = importlib.util.spec_from_file_location(module_name, file_path) + if spec is None: + raise ImportError(f"Cannot load spec for {module_name} from {file_path}") + module = importlib.util.module_from_spec(spec) + if module is None: + raise ImportError(f"Cannot load module {module_name} from spec") + sys.modules[module_name] = module + spec.loader.exec_module(module) # type: ignore + return module + + +globals().update(vars(_import_from_path(Path(__file__).parent.parent / "__init__.py"))) diff --git a/build/torch210-cu128-x86_64-windows/metadata.json b/build/torch210-cu128-x86_64-windows/metadata.json new file mode 100644 index 0000000000000000000000000000000000000000..3d6e976250acb280ddaf231891a1822d3fdfaf30 --- /dev/null +++ b/build/torch210-cu128-x86_64-windows/metadata.json @@ -0,0 +1,20 @@ +{ + "version": 1, + "python-depends": [], + "backend": { + "type": "cuda", + "archs": [ + "10.0", + "10.1", + "12.0+PTX", + "7.0", + "7.2", + "7.5", + "8.0", + "8.6", + "8.7", + "8.9", + "9.0" + ] + } +} diff --git a/build/torch210-cxx11-cu126-aarch64-linux/__init__.py b/build/torch210-cxx11-cu126-aarch64-linux/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..578e7a4b853e2a2ab5edc3df30f794ca5f0d8f00 --- /dev/null +++ b/build/torch210-cxx11-cu126-aarch64-linux/__init__.py @@ -0,0 +1,12 @@ +import torch +from typing import List + +from ._ops import ops + +def cc_2d(inputs: torch.Tensor, get_counts: bool) -> List[torch.Tensor]: + return ops.cc_2d(inputs, get_counts) + +def generic_nms(dets: torch.Tensor, scores: torch.Tensor, iou_threshold: float, use_iou_matrix: bool) -> torch.Tensor: + return ops.generic_nms(dets, scores, iou_threshold, use_iou_matrix) + +__all__ = ["cc_2d", "generic_nms"] \ No newline at end of file diff --git a/build/torch210-cxx11-cu126-aarch64-linux/_cv_utils_cuda_d91fc8d.abi3.so b/build/torch210-cxx11-cu126-aarch64-linux/_cv_utils_cuda_d91fc8d.abi3.so new file mode 100644 index 0000000000000000000000000000000000000000..1d4f980591b8882e764bd71ac5364067d22871be --- /dev/null +++ b/build/torch210-cxx11-cu126-aarch64-linux/_cv_utils_cuda_d91fc8d.abi3.so @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:85951892e9264e890bc78648406d030328cf1082440fe9ee78cdd0c519573cba +size 3168896 diff --git a/build/torch210-cxx11-cu126-aarch64-linux/_ops.py b/build/torch210-cxx11-cu126-aarch64-linux/_ops.py new file mode 100644 index 0000000000000000000000000000000000000000..f558161b89369dd5a14b0010ec991689a086588b --- /dev/null +++ b/build/torch210-cxx11-cu126-aarch64-linux/_ops.py @@ -0,0 +1,9 @@ +import torch +from . import _cv_utils_cuda_d91fc8d +ops = torch.ops._cv_utils_cuda_d91fc8d + +def add_op_namespace_prefix(op_name: str): + """ + Prefix op by namespace. + """ + return f"_cv_utils_cuda_d91fc8d::{op_name}" diff --git a/build/torch210-cxx11-cu126-aarch64-linux/cv_utils/__init__.py b/build/torch210-cxx11-cu126-aarch64-linux/cv_utils/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..a9b2672c1cd85b74c1b3ded0fc0b2100e1aeac23 --- /dev/null +++ b/build/torch210-cxx11-cu126-aarch64-linux/cv_utils/__init__.py @@ -0,0 +1,26 @@ +import ctypes +import importlib.util +import sys +from pathlib import Path +from types import ModuleType + + +def _import_from_path(file_path: Path) -> ModuleType: + # We cannot use the module name as-is, after adding it to `sys.modules`, + # it would also be used for other imports. So, we make a module name that + # depends on the path for it to be unique using the hex-encoded hash of + # the path. + path_hash = "{:x}".format(ctypes.c_size_t(hash(file_path.absolute())).value) + module_name = path_hash + spec = importlib.util.spec_from_file_location(module_name, file_path) + if spec is None: + raise ImportError(f"Cannot load spec for {module_name} from {file_path}") + module = importlib.util.module_from_spec(spec) + if module is None: + raise ImportError(f"Cannot load module {module_name} from spec") + sys.modules[module_name] = module + spec.loader.exec_module(module) # type: ignore + return module + + +globals().update(vars(_import_from_path(Path(__file__).parent.parent / "__init__.py"))) diff --git a/build/torch210-cxx11-cu126-aarch64-linux/metadata.json b/build/torch210-cxx11-cu126-aarch64-linux/metadata.json new file mode 100644 index 0000000000000000000000000000000000000000..73521ec3d40b855563f5a97cbfb4b8804b2a1213 --- /dev/null +++ b/build/torch210-cxx11-cu126-aarch64-linux/metadata.json @@ -0,0 +1,17 @@ +{ + "version": 1, + "python-depends": [], + "backend": { + "type": "cuda", + "archs": [ + "7.0", + "7.2", + "7.5", + "8.0", + "8.6", + "8.7", + "8.9", + "9.0+PTX" + ] + } +} diff --git a/build/torch210-cxx11-cu126-x86_64-linux/__init__.py b/build/torch210-cxx11-cu126-x86_64-linux/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..578e7a4b853e2a2ab5edc3df30f794ca5f0d8f00 --- /dev/null +++ b/build/torch210-cxx11-cu126-x86_64-linux/__init__.py @@ -0,0 +1,12 @@ +import torch +from typing import List + +from ._ops import ops + +def cc_2d(inputs: torch.Tensor, get_counts: bool) -> List[torch.Tensor]: + return ops.cc_2d(inputs, get_counts) + +def generic_nms(dets: torch.Tensor, scores: torch.Tensor, iou_threshold: float, use_iou_matrix: bool) -> torch.Tensor: + return ops.generic_nms(dets, scores, iou_threshold, use_iou_matrix) + +__all__ = ["cc_2d", "generic_nms"] \ No newline at end of file diff --git a/build/torch210-cxx11-cu126-x86_64-linux/_cv_utils_cuda_d91fc8d.abi3.so b/build/torch210-cxx11-cu126-x86_64-linux/_cv_utils_cuda_d91fc8d.abi3.so new file mode 100644 index 0000000000000000000000000000000000000000..2969eb34bed4b8c59ffec75899642b3f46560fb1 --- /dev/null +++ b/build/torch210-cxx11-cu126-x86_64-linux/_cv_utils_cuda_d91fc8d.abi3.so @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:8570f8f8239587bffe735225297b3c68d6687599301bc53dd70c3dd059306b0c +size 3049648 diff --git a/build/torch210-cxx11-cu126-x86_64-linux/_ops.py b/build/torch210-cxx11-cu126-x86_64-linux/_ops.py new file mode 100644 index 0000000000000000000000000000000000000000..f558161b89369dd5a14b0010ec991689a086588b --- /dev/null +++ b/build/torch210-cxx11-cu126-x86_64-linux/_ops.py @@ -0,0 +1,9 @@ +import torch +from . import _cv_utils_cuda_d91fc8d +ops = torch.ops._cv_utils_cuda_d91fc8d + +def add_op_namespace_prefix(op_name: str): + """ + Prefix op by namespace. + """ + return f"_cv_utils_cuda_d91fc8d::{op_name}" diff --git a/build/torch210-cxx11-cu126-x86_64-linux/cv_utils/__init__.py b/build/torch210-cxx11-cu126-x86_64-linux/cv_utils/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..a9b2672c1cd85b74c1b3ded0fc0b2100e1aeac23 --- /dev/null +++ b/build/torch210-cxx11-cu126-x86_64-linux/cv_utils/__init__.py @@ -0,0 +1,26 @@ +import ctypes +import importlib.util +import sys +from pathlib import Path +from types import ModuleType + + +def _import_from_path(file_path: Path) -> ModuleType: + # We cannot use the module name as-is, after adding it to `sys.modules`, + # it would also be used for other imports. So, we make a module name that + # depends on the path for it to be unique using the hex-encoded hash of + # the path. + path_hash = "{:x}".format(ctypes.c_size_t(hash(file_path.absolute())).value) + module_name = path_hash + spec = importlib.util.spec_from_file_location(module_name, file_path) + if spec is None: + raise ImportError(f"Cannot load spec for {module_name} from {file_path}") + module = importlib.util.module_from_spec(spec) + if module is None: + raise ImportError(f"Cannot load module {module_name} from spec") + sys.modules[module_name] = module + spec.loader.exec_module(module) # type: ignore + return module + + +globals().update(vars(_import_from_path(Path(__file__).parent.parent / "__init__.py"))) diff --git a/build/torch210-cxx11-cu126-x86_64-linux/metadata.json b/build/torch210-cxx11-cu126-x86_64-linux/metadata.json new file mode 100644 index 0000000000000000000000000000000000000000..73521ec3d40b855563f5a97cbfb4b8804b2a1213 --- /dev/null +++ b/build/torch210-cxx11-cu126-x86_64-linux/metadata.json @@ -0,0 +1,17 @@ +{ + "version": 1, + "python-depends": [], + "backend": { + "type": "cuda", + "archs": [ + "7.0", + "7.2", + "7.5", + "8.0", + "8.6", + "8.7", + "8.9", + "9.0+PTX" + ] + } +} diff --git a/build/torch210-cxx11-cu128-aarch64-linux/__init__.py b/build/torch210-cxx11-cu128-aarch64-linux/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..578e7a4b853e2a2ab5edc3df30f794ca5f0d8f00 --- /dev/null +++ b/build/torch210-cxx11-cu128-aarch64-linux/__init__.py @@ -0,0 +1,12 @@ +import torch +from typing import List + +from ._ops import ops + +def cc_2d(inputs: torch.Tensor, get_counts: bool) -> List[torch.Tensor]: + return ops.cc_2d(inputs, get_counts) + +def generic_nms(dets: torch.Tensor, scores: torch.Tensor, iou_threshold: float, use_iou_matrix: bool) -> torch.Tensor: + return ops.generic_nms(dets, scores, iou_threshold, use_iou_matrix) + +__all__ = ["cc_2d", "generic_nms"] \ No newline at end of file diff --git a/build/torch210-cxx11-cu128-aarch64-linux/_cv_utils_cuda_d91fc8d.abi3.so b/build/torch210-cxx11-cu128-aarch64-linux/_cv_utils_cuda_d91fc8d.abi3.so new file mode 100644 index 0000000000000000000000000000000000000000..9dbd95600751dd89f23d77794b1c3dbecddcd2d8 --- /dev/null +++ b/build/torch210-cxx11-cu128-aarch64-linux/_cv_utils_cuda_d91fc8d.abi3.so @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:2c80b066ed750b4a5b7f1f11a0d77427f0f0e99118ccbd9b8317c67f5a86adad +size 3824424 diff --git a/build/torch210-cxx11-cu128-aarch64-linux/_ops.py b/build/torch210-cxx11-cu128-aarch64-linux/_ops.py new file mode 100644 index 0000000000000000000000000000000000000000..f558161b89369dd5a14b0010ec991689a086588b --- /dev/null +++ b/build/torch210-cxx11-cu128-aarch64-linux/_ops.py @@ -0,0 +1,9 @@ +import torch +from . import _cv_utils_cuda_d91fc8d +ops = torch.ops._cv_utils_cuda_d91fc8d + +def add_op_namespace_prefix(op_name: str): + """ + Prefix op by namespace. + """ + return f"_cv_utils_cuda_d91fc8d::{op_name}" diff --git a/build/torch210-cxx11-cu128-aarch64-linux/cv_utils/__init__.py b/build/torch210-cxx11-cu128-aarch64-linux/cv_utils/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..a9b2672c1cd85b74c1b3ded0fc0b2100e1aeac23 --- /dev/null +++ b/build/torch210-cxx11-cu128-aarch64-linux/cv_utils/__init__.py @@ -0,0 +1,26 @@ +import ctypes +import importlib.util +import sys +from pathlib import Path +from types import ModuleType + + +def _import_from_path(file_path: Path) -> ModuleType: + # We cannot use the module name as-is, after adding it to `sys.modules`, + # it would also be used for other imports. So, we make a module name that + # depends on the path for it to be unique using the hex-encoded hash of + # the path. + path_hash = "{:x}".format(ctypes.c_size_t(hash(file_path.absolute())).value) + module_name = path_hash + spec = importlib.util.spec_from_file_location(module_name, file_path) + if spec is None: + raise ImportError(f"Cannot load spec for {module_name} from {file_path}") + module = importlib.util.module_from_spec(spec) + if module is None: + raise ImportError(f"Cannot load module {module_name} from spec") + sys.modules[module_name] = module + spec.loader.exec_module(module) # type: ignore + return module + + +globals().update(vars(_import_from_path(Path(__file__).parent.parent / "__init__.py"))) diff --git a/build/torch210-cxx11-cu128-aarch64-linux/metadata.json b/build/torch210-cxx11-cu128-aarch64-linux/metadata.json new file mode 100644 index 0000000000000000000000000000000000000000..e8434d821584ca7b32e25d9cda24dae18561df8b --- /dev/null +++ b/build/torch210-cxx11-cu128-aarch64-linux/metadata.json @@ -0,0 +1,20 @@ +{ + "version": 1, + "python-depends": [], + "backend": { + "type": "cuda", + "archs": [ + "10.0", + "10.1", + "12.0+PTX", + "7.0", + "7.2", + "7.5", + "8.0", + "8.6", + "8.7", + "8.9", + "9.0" + ] + } +} diff --git a/build/torch210-cxx11-cu128-x86_64-linux/__init__.py b/build/torch210-cxx11-cu128-x86_64-linux/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..578e7a4b853e2a2ab5edc3df30f794ca5f0d8f00 --- /dev/null +++ b/build/torch210-cxx11-cu128-x86_64-linux/__init__.py @@ -0,0 +1,12 @@ +import torch +from typing import List + +from ._ops import ops + +def cc_2d(inputs: torch.Tensor, get_counts: bool) -> List[torch.Tensor]: + return ops.cc_2d(inputs, get_counts) + +def generic_nms(dets: torch.Tensor, scores: torch.Tensor, iou_threshold: float, use_iou_matrix: bool) -> torch.Tensor: + return ops.generic_nms(dets, scores, iou_threshold, use_iou_matrix) + +__all__ = ["cc_2d", "generic_nms"] \ No newline at end of file diff --git a/build/torch210-cxx11-cu128-x86_64-linux/_cv_utils_cuda_d91fc8d.abi3.so b/build/torch210-cxx11-cu128-x86_64-linux/_cv_utils_cuda_d91fc8d.abi3.so new file mode 100644 index 0000000000000000000000000000000000000000..bbd3403ded97e91028edaa8d8148ddc09a25719f --- /dev/null +++ b/build/torch210-cxx11-cu128-x86_64-linux/_cv_utils_cuda_d91fc8d.abi3.so @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:af1c42d352ffee1254cbfcb240d0e6b3aa12b3db7a42720952b368e1abcf480e +size 3735552 diff --git a/build/torch210-cxx11-cu128-x86_64-linux/_ops.py b/build/torch210-cxx11-cu128-x86_64-linux/_ops.py new file mode 100644 index 0000000000000000000000000000000000000000..f558161b89369dd5a14b0010ec991689a086588b --- /dev/null +++ b/build/torch210-cxx11-cu128-x86_64-linux/_ops.py @@ -0,0 +1,9 @@ +import torch +from . import _cv_utils_cuda_d91fc8d +ops = torch.ops._cv_utils_cuda_d91fc8d + +def add_op_namespace_prefix(op_name: str): + """ + Prefix op by namespace. + """ + return f"_cv_utils_cuda_d91fc8d::{op_name}" diff --git a/build/torch210-cxx11-cu128-x86_64-linux/cv_utils/__init__.py b/build/torch210-cxx11-cu128-x86_64-linux/cv_utils/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..a9b2672c1cd85b74c1b3ded0fc0b2100e1aeac23 --- /dev/null +++ b/build/torch210-cxx11-cu128-x86_64-linux/cv_utils/__init__.py @@ -0,0 +1,26 @@ +import ctypes +import importlib.util +import sys +from pathlib import Path +from types import ModuleType + + +def _import_from_path(file_path: Path) -> ModuleType: + # We cannot use the module name as-is, after adding it to `sys.modules`, + # it would also be used for other imports. So, we make a module name that + # depends on the path for it to be unique using the hex-encoded hash of + # the path. + path_hash = "{:x}".format(ctypes.c_size_t(hash(file_path.absolute())).value) + module_name = path_hash + spec = importlib.util.spec_from_file_location(module_name, file_path) + if spec is None: + raise ImportError(f"Cannot load spec for {module_name} from {file_path}") + module = importlib.util.module_from_spec(spec) + if module is None: + raise ImportError(f"Cannot load module {module_name} from spec") + sys.modules[module_name] = module + spec.loader.exec_module(module) # type: ignore + return module + + +globals().update(vars(_import_from_path(Path(__file__).parent.parent / "__init__.py"))) diff --git a/build/torch210-cxx11-cu128-x86_64-linux/metadata.json b/build/torch210-cxx11-cu128-x86_64-linux/metadata.json new file mode 100644 index 0000000000000000000000000000000000000000..e8434d821584ca7b32e25d9cda24dae18561df8b --- /dev/null +++ b/build/torch210-cxx11-cu128-x86_64-linux/metadata.json @@ -0,0 +1,20 @@ +{ + "version": 1, + "python-depends": [], + "backend": { + "type": "cuda", + "archs": [ + "10.0", + "10.1", + "12.0+PTX", + "7.0", + "7.2", + "7.5", + "8.0", + "8.6", + "8.7", + "8.9", + "9.0" + ] + } +} diff --git a/build/torch210-cxx11-cu130-aarch64-linux/__init__.py b/build/torch210-cxx11-cu130-aarch64-linux/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..578e7a4b853e2a2ab5edc3df30f794ca5f0d8f00 --- /dev/null +++ b/build/torch210-cxx11-cu130-aarch64-linux/__init__.py @@ -0,0 +1,12 @@ +import torch +from typing import List + +from ._ops import ops + +def cc_2d(inputs: torch.Tensor, get_counts: bool) -> List[torch.Tensor]: + return ops.cc_2d(inputs, get_counts) + +def generic_nms(dets: torch.Tensor, scores: torch.Tensor, iou_threshold: float, use_iou_matrix: bool) -> torch.Tensor: + return ops.generic_nms(dets, scores, iou_threshold, use_iou_matrix) + +__all__ = ["cc_2d", "generic_nms"] \ No newline at end of file diff --git a/build/torch210-cxx11-cu130-aarch64-linux/_cv_utils_cuda_d91fc8d.abi3.so b/build/torch210-cxx11-cu130-aarch64-linux/_cv_utils_cuda_d91fc8d.abi3.so new file mode 100644 index 0000000000000000000000000000000000000000..7ff4ffb0b04206f7d19017e93028b772889b0657 --- /dev/null +++ b/build/torch210-cxx11-cu130-aarch64-linux/_cv_utils_cuda_d91fc8d.abi3.so @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:7483b27cbdd39dbe19814440aa97a22fce61635c2cb22ce510a5430d75a99d69 +size 3633848 diff --git a/build/torch210-cxx11-cu130-aarch64-linux/_ops.py b/build/torch210-cxx11-cu130-aarch64-linux/_ops.py new file mode 100644 index 0000000000000000000000000000000000000000..f558161b89369dd5a14b0010ec991689a086588b --- /dev/null +++ b/build/torch210-cxx11-cu130-aarch64-linux/_ops.py @@ -0,0 +1,9 @@ +import torch +from . import _cv_utils_cuda_d91fc8d +ops = torch.ops._cv_utils_cuda_d91fc8d + +def add_op_namespace_prefix(op_name: str): + """ + Prefix op by namespace. + """ + return f"_cv_utils_cuda_d91fc8d::{op_name}" diff --git a/build/torch210-cxx11-cu130-aarch64-linux/cv_utils/__init__.py b/build/torch210-cxx11-cu130-aarch64-linux/cv_utils/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..a9b2672c1cd85b74c1b3ded0fc0b2100e1aeac23 --- /dev/null +++ b/build/torch210-cxx11-cu130-aarch64-linux/cv_utils/__init__.py @@ -0,0 +1,26 @@ +import ctypes +import importlib.util +import sys +from pathlib import Path +from types import ModuleType + + +def _import_from_path(file_path: Path) -> ModuleType: + # We cannot use the module name as-is, after adding it to `sys.modules`, + # it would also be used for other imports. So, we make a module name that + # depends on the path for it to be unique using the hex-encoded hash of + # the path. + path_hash = "{:x}".format(ctypes.c_size_t(hash(file_path.absolute())).value) + module_name = path_hash + spec = importlib.util.spec_from_file_location(module_name, file_path) + if spec is None: + raise ImportError(f"Cannot load spec for {module_name} from {file_path}") + module = importlib.util.module_from_spec(spec) + if module is None: + raise ImportError(f"Cannot load module {module_name} from spec") + sys.modules[module_name] = module + spec.loader.exec_module(module) # type: ignore + return module + + +globals().update(vars(_import_from_path(Path(__file__).parent.parent / "__init__.py"))) diff --git a/build/torch210-cxx11-cu130-aarch64-linux/metadata.json b/build/torch210-cxx11-cu130-aarch64-linux/metadata.json new file mode 100644 index 0000000000000000000000000000000000000000..6255e63ff003b42aa6279cd430bf3bd493c6aa31 --- /dev/null +++ b/build/torch210-cxx11-cu130-aarch64-linux/metadata.json @@ -0,0 +1,18 @@ +{ + "version": 1, + "python-depends": [], + "backend": { + "type": "cuda", + "archs": [ + "10.0", + "11.0", + "12.0+PTX", + "7.5", + "8.0", + "8.6", + "8.7", + "8.9", + "9.0" + ] + } +} diff --git a/build/torch210-cxx11-cu130-x86_64-linux/__init__.py b/build/torch210-cxx11-cu130-x86_64-linux/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..578e7a4b853e2a2ab5edc3df30f794ca5f0d8f00 --- /dev/null +++ b/build/torch210-cxx11-cu130-x86_64-linux/__init__.py @@ -0,0 +1,12 @@ +import torch +from typing import List + +from ._ops import ops + +def cc_2d(inputs: torch.Tensor, get_counts: bool) -> List[torch.Tensor]: + return ops.cc_2d(inputs, get_counts) + +def generic_nms(dets: torch.Tensor, scores: torch.Tensor, iou_threshold: float, use_iou_matrix: bool) -> torch.Tensor: + return ops.generic_nms(dets, scores, iou_threshold, use_iou_matrix) + +__all__ = ["cc_2d", "generic_nms"] \ No newline at end of file diff --git a/build/torch210-cxx11-cu130-x86_64-linux/_cv_utils_cuda_d91fc8d.abi3.so b/build/torch210-cxx11-cu130-x86_64-linux/_cv_utils_cuda_d91fc8d.abi3.so new file mode 100644 index 0000000000000000000000000000000000000000..dcaff368e0b83bd27515e3f49355bc2b00a40efa --- /dev/null +++ b/build/torch210-cxx11-cu130-x86_64-linux/_cv_utils_cuda_d91fc8d.abi3.so @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:499b4704cfef394926ac41eba5dfe418a021aafabb8508af84cfe8c146dd2703 +size 3518288 diff --git a/build/torch210-cxx11-cu130-x86_64-linux/_ops.py b/build/torch210-cxx11-cu130-x86_64-linux/_ops.py new file mode 100644 index 0000000000000000000000000000000000000000..f558161b89369dd5a14b0010ec991689a086588b --- /dev/null +++ b/build/torch210-cxx11-cu130-x86_64-linux/_ops.py @@ -0,0 +1,9 @@ +import torch +from . import _cv_utils_cuda_d91fc8d +ops = torch.ops._cv_utils_cuda_d91fc8d + +def add_op_namespace_prefix(op_name: str): + """ + Prefix op by namespace. + """ + return f"_cv_utils_cuda_d91fc8d::{op_name}" diff --git a/build/torch210-cxx11-cu130-x86_64-linux/cv_utils/__init__.py b/build/torch210-cxx11-cu130-x86_64-linux/cv_utils/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..a9b2672c1cd85b74c1b3ded0fc0b2100e1aeac23 --- /dev/null +++ b/build/torch210-cxx11-cu130-x86_64-linux/cv_utils/__init__.py @@ -0,0 +1,26 @@ +import ctypes +import importlib.util +import sys +from pathlib import Path +from types import ModuleType + + +def _import_from_path(file_path: Path) -> ModuleType: + # We cannot use the module name as-is, after adding it to `sys.modules`, + # it would also be used for other imports. So, we make a module name that + # depends on the path for it to be unique using the hex-encoded hash of + # the path. + path_hash = "{:x}".format(ctypes.c_size_t(hash(file_path.absolute())).value) + module_name = path_hash + spec = importlib.util.spec_from_file_location(module_name, file_path) + if spec is None: + raise ImportError(f"Cannot load spec for {module_name} from {file_path}") + module = importlib.util.module_from_spec(spec) + if module is None: + raise ImportError(f"Cannot load module {module_name} from spec") + sys.modules[module_name] = module + spec.loader.exec_module(module) # type: ignore + return module + + +globals().update(vars(_import_from_path(Path(__file__).parent.parent / "__init__.py"))) diff --git a/build/torch210-cxx11-cu130-x86_64-linux/metadata.json b/build/torch210-cxx11-cu130-x86_64-linux/metadata.json new file mode 100644 index 0000000000000000000000000000000000000000..6255e63ff003b42aa6279cd430bf3bd493c6aa31 --- /dev/null +++ b/build/torch210-cxx11-cu130-x86_64-linux/metadata.json @@ -0,0 +1,18 @@ +{ + "version": 1, + "python-depends": [], + "backend": { + "type": "cuda", + "archs": [ + "10.0", + "11.0", + "12.0+PTX", + "7.5", + "8.0", + "8.6", + "8.7", + "8.9", + "9.0" + ] + } +} diff --git a/build/torch211-cxx11-cu126-aarch64-linux/__init__.py b/build/torch211-cxx11-cu126-aarch64-linux/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..578e7a4b853e2a2ab5edc3df30f794ca5f0d8f00 --- /dev/null +++ b/build/torch211-cxx11-cu126-aarch64-linux/__init__.py @@ -0,0 +1,12 @@ +import torch +from typing import List + +from ._ops import ops + +def cc_2d(inputs: torch.Tensor, get_counts: bool) -> List[torch.Tensor]: + return ops.cc_2d(inputs, get_counts) + +def generic_nms(dets: torch.Tensor, scores: torch.Tensor, iou_threshold: float, use_iou_matrix: bool) -> torch.Tensor: + return ops.generic_nms(dets, scores, iou_threshold, use_iou_matrix) + +__all__ = ["cc_2d", "generic_nms"] \ No newline at end of file diff --git a/build/torch211-cxx11-cu126-aarch64-linux/_cv_utils_cuda_d91fc8d.abi3.so b/build/torch211-cxx11-cu126-aarch64-linux/_cv_utils_cuda_d91fc8d.abi3.so new file mode 100644 index 0000000000000000000000000000000000000000..26e479044b5567a57cd24851d2e92cfb7f468f3e --- /dev/null +++ b/build/torch211-cxx11-cu126-aarch64-linux/_cv_utils_cuda_d91fc8d.abi3.so @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:2dbbfc5bf524a337e8b6900179e1df4a951ce95e2453691a4fb2c9a6ca2df3b9 +size 3165104 diff --git a/build/torch211-cxx11-cu126-aarch64-linux/_ops.py b/build/torch211-cxx11-cu126-aarch64-linux/_ops.py new file mode 100644 index 0000000000000000000000000000000000000000..f558161b89369dd5a14b0010ec991689a086588b --- /dev/null +++ b/build/torch211-cxx11-cu126-aarch64-linux/_ops.py @@ -0,0 +1,9 @@ +import torch +from . import _cv_utils_cuda_d91fc8d +ops = torch.ops._cv_utils_cuda_d91fc8d + +def add_op_namespace_prefix(op_name: str): + """ + Prefix op by namespace. + """ + return f"_cv_utils_cuda_d91fc8d::{op_name}" diff --git a/build/torch211-cxx11-cu126-aarch64-linux/cv_utils/__init__.py b/build/torch211-cxx11-cu126-aarch64-linux/cv_utils/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..a9b2672c1cd85b74c1b3ded0fc0b2100e1aeac23 --- /dev/null +++ b/build/torch211-cxx11-cu126-aarch64-linux/cv_utils/__init__.py @@ -0,0 +1,26 @@ +import ctypes +import importlib.util +import sys +from pathlib import Path +from types import ModuleType + + +def _import_from_path(file_path: Path) -> ModuleType: + # We cannot use the module name as-is, after adding it to `sys.modules`, + # it would also be used for other imports. So, we make a module name that + # depends on the path for it to be unique using the hex-encoded hash of + # the path. + path_hash = "{:x}".format(ctypes.c_size_t(hash(file_path.absolute())).value) + module_name = path_hash + spec = importlib.util.spec_from_file_location(module_name, file_path) + if spec is None: + raise ImportError(f"Cannot load spec for {module_name} from {file_path}") + module = importlib.util.module_from_spec(spec) + if module is None: + raise ImportError(f"Cannot load module {module_name} from spec") + sys.modules[module_name] = module + spec.loader.exec_module(module) # type: ignore + return module + + +globals().update(vars(_import_from_path(Path(__file__).parent.parent / "__init__.py"))) diff --git a/build/torch211-cxx11-cu126-aarch64-linux/metadata.json b/build/torch211-cxx11-cu126-aarch64-linux/metadata.json new file mode 100644 index 0000000000000000000000000000000000000000..73521ec3d40b855563f5a97cbfb4b8804b2a1213 --- /dev/null +++ b/build/torch211-cxx11-cu126-aarch64-linux/metadata.json @@ -0,0 +1,17 @@ +{ + "version": 1, + "python-depends": [], + "backend": { + "type": "cuda", + "archs": [ + "7.0", + "7.2", + "7.5", + "8.0", + "8.6", + "8.7", + "8.9", + "9.0+PTX" + ] + } +} diff --git a/build/torch211-cxx11-cu126-x86_64-linux/__init__.py b/build/torch211-cxx11-cu126-x86_64-linux/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..578e7a4b853e2a2ab5edc3df30f794ca5f0d8f00 --- /dev/null +++ b/build/torch211-cxx11-cu126-x86_64-linux/__init__.py @@ -0,0 +1,12 @@ +import torch +from typing import List + +from ._ops import ops + +def cc_2d(inputs: torch.Tensor, get_counts: bool) -> List[torch.Tensor]: + return ops.cc_2d(inputs, get_counts) + +def generic_nms(dets: torch.Tensor, scores: torch.Tensor, iou_threshold: float, use_iou_matrix: bool) -> torch.Tensor: + return ops.generic_nms(dets, scores, iou_threshold, use_iou_matrix) + +__all__ = ["cc_2d", "generic_nms"] \ No newline at end of file diff --git a/build/torch211-cxx11-cu126-x86_64-linux/_cv_utils_cuda_d91fc8d.abi3.so b/build/torch211-cxx11-cu126-x86_64-linux/_cv_utils_cuda_d91fc8d.abi3.so new file mode 100644 index 0000000000000000000000000000000000000000..b7303b20b3af3c2ce8cbd785b9e000fb1813934f --- /dev/null +++ b/build/torch211-cxx11-cu126-x86_64-linux/_cv_utils_cuda_d91fc8d.abi3.so @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:41f1f524c80be56fdfd22b5a72a15a939043eaa357df32af9272cabaa74f9884 +size 3042584 diff --git a/build/torch211-cxx11-cu126-x86_64-linux/_ops.py b/build/torch211-cxx11-cu126-x86_64-linux/_ops.py new file mode 100644 index 0000000000000000000000000000000000000000..f558161b89369dd5a14b0010ec991689a086588b --- /dev/null +++ b/build/torch211-cxx11-cu126-x86_64-linux/_ops.py @@ -0,0 +1,9 @@ +import torch +from . import _cv_utils_cuda_d91fc8d +ops = torch.ops._cv_utils_cuda_d91fc8d + +def add_op_namespace_prefix(op_name: str): + """ + Prefix op by namespace. + """ + return f"_cv_utils_cuda_d91fc8d::{op_name}" diff --git a/build/torch211-cxx11-cu126-x86_64-linux/cv_utils/__init__.py b/build/torch211-cxx11-cu126-x86_64-linux/cv_utils/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..a9b2672c1cd85b74c1b3ded0fc0b2100e1aeac23 --- /dev/null +++ b/build/torch211-cxx11-cu126-x86_64-linux/cv_utils/__init__.py @@ -0,0 +1,26 @@ +import ctypes +import importlib.util +import sys +from pathlib import Path +from types import ModuleType + + +def _import_from_path(file_path: Path) -> ModuleType: + # We cannot use the module name as-is, after adding it to `sys.modules`, + # it would also be used for other imports. So, we make a module name that + # depends on the path for it to be unique using the hex-encoded hash of + # the path. + path_hash = "{:x}".format(ctypes.c_size_t(hash(file_path.absolute())).value) + module_name = path_hash + spec = importlib.util.spec_from_file_location(module_name, file_path) + if spec is None: + raise ImportError(f"Cannot load spec for {module_name} from {file_path}") + module = importlib.util.module_from_spec(spec) + if module is None: + raise ImportError(f"Cannot load module {module_name} from spec") + sys.modules[module_name] = module + spec.loader.exec_module(module) # type: ignore + return module + + +globals().update(vars(_import_from_path(Path(__file__).parent.parent / "__init__.py"))) diff --git a/build/torch211-cxx11-cu126-x86_64-linux/metadata.json b/build/torch211-cxx11-cu126-x86_64-linux/metadata.json new file mode 100644 index 0000000000000000000000000000000000000000..73521ec3d40b855563f5a97cbfb4b8804b2a1213 --- /dev/null +++ b/build/torch211-cxx11-cu126-x86_64-linux/metadata.json @@ -0,0 +1,17 @@ +{ + "version": 1, + "python-depends": [], + "backend": { + "type": "cuda", + "archs": [ + "7.0", + "7.2", + "7.5", + "8.0", + "8.6", + "8.7", + "8.9", + "9.0+PTX" + ] + } +} diff --git a/build/torch211-cxx11-cu128-aarch64-linux/__init__.py b/build/torch211-cxx11-cu128-aarch64-linux/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..578e7a4b853e2a2ab5edc3df30f794ca5f0d8f00 --- /dev/null +++ b/build/torch211-cxx11-cu128-aarch64-linux/__init__.py @@ -0,0 +1,12 @@ +import torch +from typing import List + +from ._ops import ops + +def cc_2d(inputs: torch.Tensor, get_counts: bool) -> List[torch.Tensor]: + return ops.cc_2d(inputs, get_counts) + +def generic_nms(dets: torch.Tensor, scores: torch.Tensor, iou_threshold: float, use_iou_matrix: bool) -> torch.Tensor: + return ops.generic_nms(dets, scores, iou_threshold, use_iou_matrix) + +__all__ = ["cc_2d", "generic_nms"] \ No newline at end of file diff --git a/build/torch211-cxx11-cu128-aarch64-linux/_cv_utils_cuda_d91fc8d.abi3.so b/build/torch211-cxx11-cu128-aarch64-linux/_cv_utils_cuda_d91fc8d.abi3.so new file mode 100644 index 0000000000000000000000000000000000000000..7d1d8f239496587597c0966f6a18a6971807b187 --- /dev/null +++ b/build/torch211-cxx11-cu128-aarch64-linux/_cv_utils_cuda_d91fc8d.abi3.so @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:79587ea9ec0c69d9dbcc51298483eb3794d06adb73d9e463ad7ac1ea52232e7b +size 3820640 diff --git a/build/torch211-cxx11-cu128-aarch64-linux/_ops.py b/build/torch211-cxx11-cu128-aarch64-linux/_ops.py new file mode 100644 index 0000000000000000000000000000000000000000..f558161b89369dd5a14b0010ec991689a086588b --- /dev/null +++ b/build/torch211-cxx11-cu128-aarch64-linux/_ops.py @@ -0,0 +1,9 @@ +import torch +from . import _cv_utils_cuda_d91fc8d +ops = torch.ops._cv_utils_cuda_d91fc8d + +def add_op_namespace_prefix(op_name: str): + """ + Prefix op by namespace. + """ + return f"_cv_utils_cuda_d91fc8d::{op_name}" diff --git a/build/torch211-cxx11-cu128-aarch64-linux/cv_utils/__init__.py b/build/torch211-cxx11-cu128-aarch64-linux/cv_utils/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..a9b2672c1cd85b74c1b3ded0fc0b2100e1aeac23 --- /dev/null +++ b/build/torch211-cxx11-cu128-aarch64-linux/cv_utils/__init__.py @@ -0,0 +1,26 @@ +import ctypes +import importlib.util +import sys +from pathlib import Path +from types import ModuleType + + +def _import_from_path(file_path: Path) -> ModuleType: + # We cannot use the module name as-is, after adding it to `sys.modules`, + # it would also be used for other imports. So, we make a module name that + # depends on the path for it to be unique using the hex-encoded hash of + # the path. + path_hash = "{:x}".format(ctypes.c_size_t(hash(file_path.absolute())).value) + module_name = path_hash + spec = importlib.util.spec_from_file_location(module_name, file_path) + if spec is None: + raise ImportError(f"Cannot load spec for {module_name} from {file_path}") + module = importlib.util.module_from_spec(spec) + if module is None: + raise ImportError(f"Cannot load module {module_name} from spec") + sys.modules[module_name] = module + spec.loader.exec_module(module) # type: ignore + return module + + +globals().update(vars(_import_from_path(Path(__file__).parent.parent / "__init__.py"))) diff --git a/build/torch211-cxx11-cu128-aarch64-linux/metadata.json b/build/torch211-cxx11-cu128-aarch64-linux/metadata.json new file mode 100644 index 0000000000000000000000000000000000000000..e8434d821584ca7b32e25d9cda24dae18561df8b --- /dev/null +++ b/build/torch211-cxx11-cu128-aarch64-linux/metadata.json @@ -0,0 +1,20 @@ +{ + "version": 1, + "python-depends": [], + "backend": { + "type": "cuda", + "archs": [ + "10.0", + "10.1", + "12.0+PTX", + "7.0", + "7.2", + "7.5", + "8.0", + "8.6", + "8.7", + "8.9", + "9.0" + ] + } +} diff --git a/build/torch211-cxx11-cu128-x86_64-linux/__init__.py b/build/torch211-cxx11-cu128-x86_64-linux/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..578e7a4b853e2a2ab5edc3df30f794ca5f0d8f00 --- /dev/null +++ b/build/torch211-cxx11-cu128-x86_64-linux/__init__.py @@ -0,0 +1,12 @@ +import torch +from typing import List + +from ._ops import ops + +def cc_2d(inputs: torch.Tensor, get_counts: bool) -> List[torch.Tensor]: + return ops.cc_2d(inputs, get_counts) + +def generic_nms(dets: torch.Tensor, scores: torch.Tensor, iou_threshold: float, use_iou_matrix: bool) -> torch.Tensor: + return ops.generic_nms(dets, scores, iou_threshold, use_iou_matrix) + +__all__ = ["cc_2d", "generic_nms"] \ No newline at end of file diff --git a/build/torch211-cxx11-cu128-x86_64-linux/_cv_utils_cuda_d91fc8d.abi3.so b/build/torch211-cxx11-cu128-x86_64-linux/_cv_utils_cuda_d91fc8d.abi3.so new file mode 100644 index 0000000000000000000000000000000000000000..32aaf9b8f445fd5b507aaca6140aeaa1b3d7b643 --- /dev/null +++ b/build/torch211-cxx11-cu128-x86_64-linux/_cv_utils_cuda_d91fc8d.abi3.so @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:b7df382c98bfdfb429818662c2cc43a67b6a839db3dc762b15c55b277e955442 +size 3724384 diff --git a/build/torch211-cxx11-cu128-x86_64-linux/_ops.py b/build/torch211-cxx11-cu128-x86_64-linux/_ops.py new file mode 100644 index 0000000000000000000000000000000000000000..f558161b89369dd5a14b0010ec991689a086588b --- /dev/null +++ b/build/torch211-cxx11-cu128-x86_64-linux/_ops.py @@ -0,0 +1,9 @@ +import torch +from . import _cv_utils_cuda_d91fc8d +ops = torch.ops._cv_utils_cuda_d91fc8d + +def add_op_namespace_prefix(op_name: str): + """ + Prefix op by namespace. + """ + return f"_cv_utils_cuda_d91fc8d::{op_name}" diff --git a/build/torch211-cxx11-cu128-x86_64-linux/cv_utils/__init__.py b/build/torch211-cxx11-cu128-x86_64-linux/cv_utils/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..a9b2672c1cd85b74c1b3ded0fc0b2100e1aeac23 --- /dev/null +++ b/build/torch211-cxx11-cu128-x86_64-linux/cv_utils/__init__.py @@ -0,0 +1,26 @@ +import ctypes +import importlib.util +import sys +from pathlib import Path +from types import ModuleType + + +def _import_from_path(file_path: Path) -> ModuleType: + # We cannot use the module name as-is, after adding it to `sys.modules`, + # it would also be used for other imports. So, we make a module name that + # depends on the path for it to be unique using the hex-encoded hash of + # the path. + path_hash = "{:x}".format(ctypes.c_size_t(hash(file_path.absolute())).value) + module_name = path_hash + spec = importlib.util.spec_from_file_location(module_name, file_path) + if spec is None: + raise ImportError(f"Cannot load spec for {module_name} from {file_path}") + module = importlib.util.module_from_spec(spec) + if module is None: + raise ImportError(f"Cannot load module {module_name} from spec") + sys.modules[module_name] = module + spec.loader.exec_module(module) # type: ignore + return module + + +globals().update(vars(_import_from_path(Path(__file__).parent.parent / "__init__.py"))) diff --git a/build/torch211-cxx11-cu128-x86_64-linux/metadata.json b/build/torch211-cxx11-cu128-x86_64-linux/metadata.json new file mode 100644 index 0000000000000000000000000000000000000000..e8434d821584ca7b32e25d9cda24dae18561df8b --- /dev/null +++ b/build/torch211-cxx11-cu128-x86_64-linux/metadata.json @@ -0,0 +1,20 @@ +{ + "version": 1, + "python-depends": [], + "backend": { + "type": "cuda", + "archs": [ + "10.0", + "10.1", + "12.0+PTX", + "7.0", + "7.2", + "7.5", + "8.0", + "8.6", + "8.7", + "8.9", + "9.0" + ] + } +} diff --git a/build/torch211-cxx11-cu130-aarch64-linux/__init__.py b/build/torch211-cxx11-cu130-aarch64-linux/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..578e7a4b853e2a2ab5edc3df30f794ca5f0d8f00 --- /dev/null +++ b/build/torch211-cxx11-cu130-aarch64-linux/__init__.py @@ -0,0 +1,12 @@ +import torch +from typing import List + +from ._ops import ops + +def cc_2d(inputs: torch.Tensor, get_counts: bool) -> List[torch.Tensor]: + return ops.cc_2d(inputs, get_counts) + +def generic_nms(dets: torch.Tensor, scores: torch.Tensor, iou_threshold: float, use_iou_matrix: bool) -> torch.Tensor: + return ops.generic_nms(dets, scores, iou_threshold, use_iou_matrix) + +__all__ = ["cc_2d", "generic_nms"] \ No newline at end of file diff --git a/build/torch211-cxx11-cu130-aarch64-linux/_cv_utils_cuda_d91fc8d.abi3.so b/build/torch211-cxx11-cu130-aarch64-linux/_cv_utils_cuda_d91fc8d.abi3.so new file mode 100644 index 0000000000000000000000000000000000000000..8828a3111fab0320a82317c48ad79d88f4fc8256 --- /dev/null +++ b/build/torch211-cxx11-cu130-aarch64-linux/_cv_utils_cuda_d91fc8d.abi3.so @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:a262ed16de99e85ac531e4be6db2cba240b1ba0c2de31c227c7f312455f5fe3e +size 3630056 diff --git a/build/torch211-cxx11-cu130-aarch64-linux/_ops.py b/build/torch211-cxx11-cu130-aarch64-linux/_ops.py new file mode 100644 index 0000000000000000000000000000000000000000..f558161b89369dd5a14b0010ec991689a086588b --- /dev/null +++ b/build/torch211-cxx11-cu130-aarch64-linux/_ops.py @@ -0,0 +1,9 @@ +import torch +from . import _cv_utils_cuda_d91fc8d +ops = torch.ops._cv_utils_cuda_d91fc8d + +def add_op_namespace_prefix(op_name: str): + """ + Prefix op by namespace. + """ + return f"_cv_utils_cuda_d91fc8d::{op_name}" diff --git a/build/torch211-cxx11-cu130-aarch64-linux/cv_utils/__init__.py b/build/torch211-cxx11-cu130-aarch64-linux/cv_utils/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..a9b2672c1cd85b74c1b3ded0fc0b2100e1aeac23 --- /dev/null +++ b/build/torch211-cxx11-cu130-aarch64-linux/cv_utils/__init__.py @@ -0,0 +1,26 @@ +import ctypes +import importlib.util +import sys +from pathlib import Path +from types import ModuleType + + +def _import_from_path(file_path: Path) -> ModuleType: + # We cannot use the module name as-is, after adding it to `sys.modules`, + # it would also be used for other imports. So, we make a module name that + # depends on the path for it to be unique using the hex-encoded hash of + # the path. + path_hash = "{:x}".format(ctypes.c_size_t(hash(file_path.absolute())).value) + module_name = path_hash + spec = importlib.util.spec_from_file_location(module_name, file_path) + if spec is None: + raise ImportError(f"Cannot load spec for {module_name} from {file_path}") + module = importlib.util.module_from_spec(spec) + if module is None: + raise ImportError(f"Cannot load module {module_name} from spec") + sys.modules[module_name] = module + spec.loader.exec_module(module) # type: ignore + return module + + +globals().update(vars(_import_from_path(Path(__file__).parent.parent / "__init__.py"))) diff --git a/build/torch211-cxx11-cu130-aarch64-linux/metadata.json b/build/torch211-cxx11-cu130-aarch64-linux/metadata.json new file mode 100644 index 0000000000000000000000000000000000000000..6255e63ff003b42aa6279cd430bf3bd493c6aa31 --- /dev/null +++ b/build/torch211-cxx11-cu130-aarch64-linux/metadata.json @@ -0,0 +1,18 @@ +{ + "version": 1, + "python-depends": [], + "backend": { + "type": "cuda", + "archs": [ + "10.0", + "11.0", + "12.0+PTX", + "7.5", + "8.0", + "8.6", + "8.7", + "8.9", + "9.0" + ] + } +} diff --git a/build/torch211-cxx11-cu130-x86_64-linux/__init__.py b/build/torch211-cxx11-cu130-x86_64-linux/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..578e7a4b853e2a2ab5edc3df30f794ca5f0d8f00 --- /dev/null +++ b/build/torch211-cxx11-cu130-x86_64-linux/__init__.py @@ -0,0 +1,12 @@ +import torch +from typing import List + +from ._ops import ops + +def cc_2d(inputs: torch.Tensor, get_counts: bool) -> List[torch.Tensor]: + return ops.cc_2d(inputs, get_counts) + +def generic_nms(dets: torch.Tensor, scores: torch.Tensor, iou_threshold: float, use_iou_matrix: bool) -> torch.Tensor: + return ops.generic_nms(dets, scores, iou_threshold, use_iou_matrix) + +__all__ = ["cc_2d", "generic_nms"] \ No newline at end of file diff --git a/build/torch211-cxx11-cu130-x86_64-linux/_cv_utils_cuda_d91fc8d.abi3.so b/build/torch211-cxx11-cu130-x86_64-linux/_cv_utils_cuda_d91fc8d.abi3.so new file mode 100644 index 0000000000000000000000000000000000000000..439f26751ebed7cc1b6f527ea7e1c3af9996717d --- /dev/null +++ b/build/torch211-cxx11-cu130-x86_64-linux/_cv_utils_cuda_d91fc8d.abi3.so @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:a9c91d38609e6e5e497c4b12f3a8fd1dbe0897aa8d390300a9f5a7d856f467b1 +size 3511216 diff --git a/build/torch211-cxx11-cu130-x86_64-linux/_ops.py b/build/torch211-cxx11-cu130-x86_64-linux/_ops.py new file mode 100644 index 0000000000000000000000000000000000000000..f558161b89369dd5a14b0010ec991689a086588b --- /dev/null +++ b/build/torch211-cxx11-cu130-x86_64-linux/_ops.py @@ -0,0 +1,9 @@ +import torch +from . import _cv_utils_cuda_d91fc8d +ops = torch.ops._cv_utils_cuda_d91fc8d + +def add_op_namespace_prefix(op_name: str): + """ + Prefix op by namespace. + """ + return f"_cv_utils_cuda_d91fc8d::{op_name}" diff --git a/build/torch211-cxx11-cu130-x86_64-linux/cv_utils/__init__.py b/build/torch211-cxx11-cu130-x86_64-linux/cv_utils/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..a9b2672c1cd85b74c1b3ded0fc0b2100e1aeac23 --- /dev/null +++ b/build/torch211-cxx11-cu130-x86_64-linux/cv_utils/__init__.py @@ -0,0 +1,26 @@ +import ctypes +import importlib.util +import sys +from pathlib import Path +from types import ModuleType + + +def _import_from_path(file_path: Path) -> ModuleType: + # We cannot use the module name as-is, after adding it to `sys.modules`, + # it would also be used for other imports. So, we make a module name that + # depends on the path for it to be unique using the hex-encoded hash of + # the path. + path_hash = "{:x}".format(ctypes.c_size_t(hash(file_path.absolute())).value) + module_name = path_hash + spec = importlib.util.spec_from_file_location(module_name, file_path) + if spec is None: + raise ImportError(f"Cannot load spec for {module_name} from {file_path}") + module = importlib.util.module_from_spec(spec) + if module is None: + raise ImportError(f"Cannot load module {module_name} from spec") + sys.modules[module_name] = module + spec.loader.exec_module(module) # type: ignore + return module + + +globals().update(vars(_import_from_path(Path(__file__).parent.parent / "__init__.py"))) diff --git a/build/torch211-cxx11-cu130-x86_64-linux/metadata.json b/build/torch211-cxx11-cu130-x86_64-linux/metadata.json new file mode 100644 index 0000000000000000000000000000000000000000..6255e63ff003b42aa6279cd430bf3bd493c6aa31 --- /dev/null +++ b/build/torch211-cxx11-cu130-x86_64-linux/metadata.json @@ -0,0 +1,18 @@ +{ + "version": 1, + "python-depends": [], + "backend": { + "type": "cuda", + "archs": [ + "10.0", + "11.0", + "12.0+PTX", + "7.5", + "8.0", + "8.6", + "8.7", + "8.9", + "9.0" + ] + } +} diff --git a/build/torch28-cxx11-cu126-x86_64-linux/__init__.py b/build/torch28-cxx11-cu126-x86_64-linux/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..578e7a4b853e2a2ab5edc3df30f794ca5f0d8f00 --- /dev/null +++ b/build/torch28-cxx11-cu126-x86_64-linux/__init__.py @@ -0,0 +1,12 @@ +import torch +from typing import List + +from ._ops import ops + +def cc_2d(inputs: torch.Tensor, get_counts: bool) -> List[torch.Tensor]: + return ops.cc_2d(inputs, get_counts) + +def generic_nms(dets: torch.Tensor, scores: torch.Tensor, iou_threshold: float, use_iou_matrix: bool) -> torch.Tensor: + return ops.generic_nms(dets, scores, iou_threshold, use_iou_matrix) + +__all__ = ["cc_2d", "generic_nms"] \ No newline at end of file diff --git a/build/torch28-cxx11-cu126-x86_64-linux/_cv_utils_8541a33.abi3.so b/build/torch28-cxx11-cu126-x86_64-linux/_cv_utils_8541a33.abi3.so new file mode 100644 index 0000000000000000000000000000000000000000..26ff940b4a73652e75866ca76ee842c9772a21b2 --- /dev/null +++ b/build/torch28-cxx11-cu126-x86_64-linux/_cv_utils_8541a33.abi3.so @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:965f12c73154f2a0713869b6efc763a46c8427705429893febeb5315eca44333 +size 3038768 diff --git a/build/torch28-cxx11-cu126-x86_64-linux/_ops.py b/build/torch28-cxx11-cu126-x86_64-linux/_ops.py new file mode 100644 index 0000000000000000000000000000000000000000..233ba1b7af1d885d2952b12ec2ea529933215e7e --- /dev/null +++ b/build/torch28-cxx11-cu126-x86_64-linux/_ops.py @@ -0,0 +1,9 @@ +import torch +from . import _cv_utils_8541a33 +ops = torch.ops._cv_utils_8541a33 + +def add_op_namespace_prefix(op_name: str): + """ + Prefix op by namespace. + """ + return f"_cv_utils_8541a33::{op_name}" \ No newline at end of file diff --git a/build/torch28-cxx11-cu126-x86_64-linux/cv_utils/__init__.py b/build/torch28-cxx11-cu126-x86_64-linux/cv_utils/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..03dbc1afe1cf156661a2b1b22003cd5f599a0309 --- /dev/null +++ b/build/torch28-cxx11-cu126-x86_64-linux/cv_utils/__init__.py @@ -0,0 +1,26 @@ +import ctypes +import sys + +import importlib +from pathlib import Path +from types import ModuleType + +def _import_from_path(file_path: Path) -> ModuleType: + # We cannot use the module name as-is, after adding it to `sys.modules`, + # it would also be used for other imports. So, we make a module name that + # depends on the path for it to be unique using the hex-encoded hash of + # the path. + path_hash = "{:x}".format(ctypes.c_size_t(hash(file_path.absolute())).value) + module_name = path_hash + spec = importlib.util.spec_from_file_location(module_name, file_path) + if spec is None: + raise ImportError(f"Cannot load spec for {module_name} from {file_path}") + module = importlib.util.module_from_spec(spec) + if module is None: + raise ImportError(f"Cannot load module {module_name} from spec") + sys.modules[module_name] = module + spec.loader.exec_module(module) # type: ignore + return module + + +globals().update(vars(_import_from_path(Path(__file__).parent.parent / "__init__.py"))) diff --git a/build/torch28-cxx11-cu126-x86_64-linux/metadata.json b/build/torch28-cxx11-cu126-x86_64-linux/metadata.json new file mode 100644 index 0000000000000000000000000000000000000000..9cf5deed9898dce769f4cc73913d3530b92a0bd8 --- /dev/null +++ b/build/torch28-cxx11-cu126-x86_64-linux/metadata.json @@ -0,0 +1,4 @@ +{ + "version": 1, + "python-depends": [] +} \ No newline at end of file diff --git a/build/torch28-cxx11-cu128-x86_64-linux/__init__.py b/build/torch28-cxx11-cu128-x86_64-linux/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..578e7a4b853e2a2ab5edc3df30f794ca5f0d8f00 --- /dev/null +++ b/build/torch28-cxx11-cu128-x86_64-linux/__init__.py @@ -0,0 +1,12 @@ +import torch +from typing import List + +from ._ops import ops + +def cc_2d(inputs: torch.Tensor, get_counts: bool) -> List[torch.Tensor]: + return ops.cc_2d(inputs, get_counts) + +def generic_nms(dets: torch.Tensor, scores: torch.Tensor, iou_threshold: float, use_iou_matrix: bool) -> torch.Tensor: + return ops.generic_nms(dets, scores, iou_threshold, use_iou_matrix) + +__all__ = ["cc_2d", "generic_nms"] \ No newline at end of file diff --git a/build/torch28-cxx11-cu128-x86_64-linux/_cv_utils_8541a33.abi3.so b/build/torch28-cxx11-cu128-x86_64-linux/_cv_utils_8541a33.abi3.so new file mode 100644 index 0000000000000000000000000000000000000000..21e25e429c432ba9a51888aaf6db6c88fc8c8ad1 --- /dev/null +++ b/build/torch28-cxx11-cu128-x86_64-linux/_cv_utils_8541a33.abi3.so @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:8cc8f3bb21c53b3e39cc1a05bb40b8944429523659dd12dfbb613f1fa8e1d578 +size 3720296 diff --git a/build/torch28-cxx11-cu128-x86_64-linux/_ops.py b/build/torch28-cxx11-cu128-x86_64-linux/_ops.py new file mode 100644 index 0000000000000000000000000000000000000000..233ba1b7af1d885d2952b12ec2ea529933215e7e --- /dev/null +++ b/build/torch28-cxx11-cu128-x86_64-linux/_ops.py @@ -0,0 +1,9 @@ +import torch +from . import _cv_utils_8541a33 +ops = torch.ops._cv_utils_8541a33 + +def add_op_namespace_prefix(op_name: str): + """ + Prefix op by namespace. + """ + return f"_cv_utils_8541a33::{op_name}" \ No newline at end of file diff --git a/build/torch28-cxx11-cu128-x86_64-linux/cv_utils/__init__.py b/build/torch28-cxx11-cu128-x86_64-linux/cv_utils/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..03dbc1afe1cf156661a2b1b22003cd5f599a0309 --- /dev/null +++ b/build/torch28-cxx11-cu128-x86_64-linux/cv_utils/__init__.py @@ -0,0 +1,26 @@ +import ctypes +import sys + +import importlib +from pathlib import Path +from types import ModuleType + +def _import_from_path(file_path: Path) -> ModuleType: + # We cannot use the module name as-is, after adding it to `sys.modules`, + # it would also be used for other imports. So, we make a module name that + # depends on the path for it to be unique using the hex-encoded hash of + # the path. + path_hash = "{:x}".format(ctypes.c_size_t(hash(file_path.absolute())).value) + module_name = path_hash + spec = importlib.util.spec_from_file_location(module_name, file_path) + if spec is None: + raise ImportError(f"Cannot load spec for {module_name} from {file_path}") + module = importlib.util.module_from_spec(spec) + if module is None: + raise ImportError(f"Cannot load module {module_name} from spec") + sys.modules[module_name] = module + spec.loader.exec_module(module) # type: ignore + return module + + +globals().update(vars(_import_from_path(Path(__file__).parent.parent / "__init__.py"))) diff --git a/build/torch28-cxx11-cu128-x86_64-linux/metadata.json b/build/torch28-cxx11-cu128-x86_64-linux/metadata.json new file mode 100644 index 0000000000000000000000000000000000000000..9cf5deed9898dce769f4cc73913d3530b92a0bd8 --- /dev/null +++ b/build/torch28-cxx11-cu128-x86_64-linux/metadata.json @@ -0,0 +1,4 @@ +{ + "version": 1, + "python-depends": [] +} \ No newline at end of file diff --git a/build/torch28-cxx11-cu129-x86_64-linux/__init__.py b/build/torch28-cxx11-cu129-x86_64-linux/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..578e7a4b853e2a2ab5edc3df30f794ca5f0d8f00 --- /dev/null +++ b/build/torch28-cxx11-cu129-x86_64-linux/__init__.py @@ -0,0 +1,12 @@ +import torch +from typing import List + +from ._ops import ops + +def cc_2d(inputs: torch.Tensor, get_counts: bool) -> List[torch.Tensor]: + return ops.cc_2d(inputs, get_counts) + +def generic_nms(dets: torch.Tensor, scores: torch.Tensor, iou_threshold: float, use_iou_matrix: bool) -> torch.Tensor: + return ops.generic_nms(dets, scores, iou_threshold, use_iou_matrix) + +__all__ = ["cc_2d", "generic_nms"] \ No newline at end of file diff --git a/build/torch28-cxx11-cu129-x86_64-linux/_cv_utils_8541a33.abi3.so b/build/torch28-cxx11-cu129-x86_64-linux/_cv_utils_8541a33.abi3.so new file mode 100644 index 0000000000000000000000000000000000000000..c80caa8f298653a9a432814a1d5b0b526cbf37ce --- /dev/null +++ b/build/torch28-cxx11-cu129-x86_64-linux/_cv_utils_8541a33.abi3.so @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:3468fd8bd586ae6aee2e0f5d3c124f99fdd14c82823f4de07208505a4646c72e +size 3688520 diff --git a/build/torch28-cxx11-cu129-x86_64-linux/_ops.py b/build/torch28-cxx11-cu129-x86_64-linux/_ops.py new file mode 100644 index 0000000000000000000000000000000000000000..233ba1b7af1d885d2952b12ec2ea529933215e7e --- /dev/null +++ b/build/torch28-cxx11-cu129-x86_64-linux/_ops.py @@ -0,0 +1,9 @@ +import torch +from . import _cv_utils_8541a33 +ops = torch.ops._cv_utils_8541a33 + +def add_op_namespace_prefix(op_name: str): + """ + Prefix op by namespace. + """ + return f"_cv_utils_8541a33::{op_name}" \ No newline at end of file diff --git a/build/torch28-cxx11-cu129-x86_64-linux/cv_utils/__init__.py b/build/torch28-cxx11-cu129-x86_64-linux/cv_utils/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..03dbc1afe1cf156661a2b1b22003cd5f599a0309 --- /dev/null +++ b/build/torch28-cxx11-cu129-x86_64-linux/cv_utils/__init__.py @@ -0,0 +1,26 @@ +import ctypes +import sys + +import importlib +from pathlib import Path +from types import ModuleType + +def _import_from_path(file_path: Path) -> ModuleType: + # We cannot use the module name as-is, after adding it to `sys.modules`, + # it would also be used for other imports. So, we make a module name that + # depends on the path for it to be unique using the hex-encoded hash of + # the path. + path_hash = "{:x}".format(ctypes.c_size_t(hash(file_path.absolute())).value) + module_name = path_hash + spec = importlib.util.spec_from_file_location(module_name, file_path) + if spec is None: + raise ImportError(f"Cannot load spec for {module_name} from {file_path}") + module = importlib.util.module_from_spec(spec) + if module is None: + raise ImportError(f"Cannot load module {module_name} from spec") + sys.modules[module_name] = module + spec.loader.exec_module(module) # type: ignore + return module + + +globals().update(vars(_import_from_path(Path(__file__).parent.parent / "__init__.py"))) diff --git a/build/torch28-cxx11-cu129-x86_64-linux/metadata.json b/build/torch28-cxx11-cu129-x86_64-linux/metadata.json new file mode 100644 index 0000000000000000000000000000000000000000..9cf5deed9898dce769f4cc73913d3530b92a0bd8 --- /dev/null +++ b/build/torch28-cxx11-cu129-x86_64-linux/metadata.json @@ -0,0 +1,4 @@ +{ + "version": 1, + "python-depends": [] +} \ No newline at end of file diff --git a/build/torch29-cxx11-cu126-aarch64-linux/__init__.py b/build/torch29-cxx11-cu126-aarch64-linux/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..578e7a4b853e2a2ab5edc3df30f794ca5f0d8f00 --- /dev/null +++ b/build/torch29-cxx11-cu126-aarch64-linux/__init__.py @@ -0,0 +1,12 @@ +import torch +from typing import List + +from ._ops import ops + +def cc_2d(inputs: torch.Tensor, get_counts: bool) -> List[torch.Tensor]: + return ops.cc_2d(inputs, get_counts) + +def generic_nms(dets: torch.Tensor, scores: torch.Tensor, iou_threshold: float, use_iou_matrix: bool) -> torch.Tensor: + return ops.generic_nms(dets, scores, iou_threshold, use_iou_matrix) + +__all__ = ["cc_2d", "generic_nms"] \ No newline at end of file diff --git a/build/torch29-cxx11-cu126-aarch64-linux/_cv_utils_cuda_8cfc281.abi3.so b/build/torch29-cxx11-cu126-aarch64-linux/_cv_utils_cuda_8cfc281.abi3.so new file mode 100644 index 0000000000000000000000000000000000000000..85c995a5e404bde4be2ffb674a2e2f7b4228b4f6 --- /dev/null +++ b/build/torch29-cxx11-cu126-aarch64-linux/_cv_utils_cuda_8cfc281.abi3.so @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:bb8cff7b3e4834dcedbac0058de07b8b9a50a72e3d73a591710994b27c58fba3 +size 3165512 diff --git a/build/torch29-cxx11-cu126-aarch64-linux/_ops.py b/build/torch29-cxx11-cu126-aarch64-linux/_ops.py new file mode 100644 index 0000000000000000000000000000000000000000..48d9641f50e19021591d4bc06f39ba88b48a9616 --- /dev/null +++ b/build/torch29-cxx11-cu126-aarch64-linux/_ops.py @@ -0,0 +1,9 @@ +import torch +from . import _cv_utils_cuda_8cfc281 +ops = torch.ops._cv_utils_cuda_8cfc281 + +def add_op_namespace_prefix(op_name: str): + """ + Prefix op by namespace. + """ + return f"_cv_utils_cuda_8cfc281::{op_name}" diff --git a/build/torch29-cxx11-cu126-aarch64-linux/cv_utils/__init__.py b/build/torch29-cxx11-cu126-aarch64-linux/cv_utils/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..03dbc1afe1cf156661a2b1b22003cd5f599a0309 --- /dev/null +++ b/build/torch29-cxx11-cu126-aarch64-linux/cv_utils/__init__.py @@ -0,0 +1,26 @@ +import ctypes +import sys + +import importlib +from pathlib import Path +from types import ModuleType + +def _import_from_path(file_path: Path) -> ModuleType: + # We cannot use the module name as-is, after adding it to `sys.modules`, + # it would also be used for other imports. So, we make a module name that + # depends on the path for it to be unique using the hex-encoded hash of + # the path. + path_hash = "{:x}".format(ctypes.c_size_t(hash(file_path.absolute())).value) + module_name = path_hash + spec = importlib.util.spec_from_file_location(module_name, file_path) + if spec is None: + raise ImportError(f"Cannot load spec for {module_name} from {file_path}") + module = importlib.util.module_from_spec(spec) + if module is None: + raise ImportError(f"Cannot load module {module_name} from spec") + sys.modules[module_name] = module + spec.loader.exec_module(module) # type: ignore + return module + + +globals().update(vars(_import_from_path(Path(__file__).parent.parent / "__init__.py"))) diff --git a/build/torch29-cxx11-cu126-aarch64-linux/metadata.json b/build/torch29-cxx11-cu126-aarch64-linux/metadata.json new file mode 100644 index 0000000000000000000000000000000000000000..73521ec3d40b855563f5a97cbfb4b8804b2a1213 --- /dev/null +++ b/build/torch29-cxx11-cu126-aarch64-linux/metadata.json @@ -0,0 +1,17 @@ +{ + "version": 1, + "python-depends": [], + "backend": { + "type": "cuda", + "archs": [ + "7.0", + "7.2", + "7.5", + "8.0", + "8.6", + "8.7", + "8.9", + "9.0+PTX" + ] + } +} diff --git a/build/torch29-cxx11-cu126-x86_64-linux/__init__.py b/build/torch29-cxx11-cu126-x86_64-linux/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..578e7a4b853e2a2ab5edc3df30f794ca5f0d8f00 --- /dev/null +++ b/build/torch29-cxx11-cu126-x86_64-linux/__init__.py @@ -0,0 +1,12 @@ +import torch +from typing import List + +from ._ops import ops + +def cc_2d(inputs: torch.Tensor, get_counts: bool) -> List[torch.Tensor]: + return ops.cc_2d(inputs, get_counts) + +def generic_nms(dets: torch.Tensor, scores: torch.Tensor, iou_threshold: float, use_iou_matrix: bool) -> torch.Tensor: + return ops.generic_nms(dets, scores, iou_threshold, use_iou_matrix) + +__all__ = ["cc_2d", "generic_nms"] \ No newline at end of file diff --git a/build/torch29-cxx11-cu126-x86_64-linux/_cv_utils_cuda_8cfc281.abi3.so b/build/torch29-cxx11-cu126-x86_64-linux/_cv_utils_cuda_8cfc281.abi3.so new file mode 100644 index 0000000000000000000000000000000000000000..15c69146e7494f5acf16f69138a066530d39b002 --- /dev/null +++ b/build/torch29-cxx11-cu126-x86_64-linux/_cv_utils_cuda_8cfc281.abi3.so @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:1d4c140f8e7922ff5068567f59977821d5163fa4f13c16d7f08f9b4eb83c353b +size 3038896 diff --git a/build/torch29-cxx11-cu126-x86_64-linux/_ops.py b/build/torch29-cxx11-cu126-x86_64-linux/_ops.py new file mode 100644 index 0000000000000000000000000000000000000000..48d9641f50e19021591d4bc06f39ba88b48a9616 --- /dev/null +++ b/build/torch29-cxx11-cu126-x86_64-linux/_ops.py @@ -0,0 +1,9 @@ +import torch +from . import _cv_utils_cuda_8cfc281 +ops = torch.ops._cv_utils_cuda_8cfc281 + +def add_op_namespace_prefix(op_name: str): + """ + Prefix op by namespace. + """ + return f"_cv_utils_cuda_8cfc281::{op_name}" diff --git a/build/torch29-cxx11-cu126-x86_64-linux/cv_utils/__init__.py b/build/torch29-cxx11-cu126-x86_64-linux/cv_utils/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..03dbc1afe1cf156661a2b1b22003cd5f599a0309 --- /dev/null +++ b/build/torch29-cxx11-cu126-x86_64-linux/cv_utils/__init__.py @@ -0,0 +1,26 @@ +import ctypes +import sys + +import importlib +from pathlib import Path +from types import ModuleType + +def _import_from_path(file_path: Path) -> ModuleType: + # We cannot use the module name as-is, after adding it to `sys.modules`, + # it would also be used for other imports. So, we make a module name that + # depends on the path for it to be unique using the hex-encoded hash of + # the path. + path_hash = "{:x}".format(ctypes.c_size_t(hash(file_path.absolute())).value) + module_name = path_hash + spec = importlib.util.spec_from_file_location(module_name, file_path) + if spec is None: + raise ImportError(f"Cannot load spec for {module_name} from {file_path}") + module = importlib.util.module_from_spec(spec) + if module is None: + raise ImportError(f"Cannot load module {module_name} from spec") + sys.modules[module_name] = module + spec.loader.exec_module(module) # type: ignore + return module + + +globals().update(vars(_import_from_path(Path(__file__).parent.parent / "__init__.py"))) diff --git a/build/torch29-cxx11-cu126-x86_64-linux/metadata.json b/build/torch29-cxx11-cu126-x86_64-linux/metadata.json new file mode 100644 index 0000000000000000000000000000000000000000..73521ec3d40b855563f5a97cbfb4b8804b2a1213 --- /dev/null +++ b/build/torch29-cxx11-cu126-x86_64-linux/metadata.json @@ -0,0 +1,17 @@ +{ + "version": 1, + "python-depends": [], + "backend": { + "type": "cuda", + "archs": [ + "7.0", + "7.2", + "7.5", + "8.0", + "8.6", + "8.7", + "8.9", + "9.0+PTX" + ] + } +} diff --git a/build/torch29-cxx11-cu128-aarch64-linux/__init__.py b/build/torch29-cxx11-cu128-aarch64-linux/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..578e7a4b853e2a2ab5edc3df30f794ca5f0d8f00 --- /dev/null +++ b/build/torch29-cxx11-cu128-aarch64-linux/__init__.py @@ -0,0 +1,12 @@ +import torch +from typing import List + +from ._ops import ops + +def cc_2d(inputs: torch.Tensor, get_counts: bool) -> List[torch.Tensor]: + return ops.cc_2d(inputs, get_counts) + +def generic_nms(dets: torch.Tensor, scores: torch.Tensor, iou_threshold: float, use_iou_matrix: bool) -> torch.Tensor: + return ops.generic_nms(dets, scores, iou_threshold, use_iou_matrix) + +__all__ = ["cc_2d", "generic_nms"] \ No newline at end of file diff --git a/build/torch29-cxx11-cu128-aarch64-linux/_cv_utils_cuda_8cfc281.abi3.so b/build/torch29-cxx11-cu128-aarch64-linux/_cv_utils_cuda_8cfc281.abi3.so new file mode 100644 index 0000000000000000000000000000000000000000..57a5237a52cfdd8314a952e3ffda95d33c601dd0 --- /dev/null +++ b/build/torch29-cxx11-cu128-aarch64-linux/_cv_utils_cuda_8cfc281.abi3.so @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:b8fa241565cfdede03164f1722d4e31307f9658aca61020deada6bed653e7a91 +size 3820720 diff --git a/build/torch29-cxx11-cu128-aarch64-linux/_ops.py b/build/torch29-cxx11-cu128-aarch64-linux/_ops.py new file mode 100644 index 0000000000000000000000000000000000000000..48d9641f50e19021591d4bc06f39ba88b48a9616 --- /dev/null +++ b/build/torch29-cxx11-cu128-aarch64-linux/_ops.py @@ -0,0 +1,9 @@ +import torch +from . import _cv_utils_cuda_8cfc281 +ops = torch.ops._cv_utils_cuda_8cfc281 + +def add_op_namespace_prefix(op_name: str): + """ + Prefix op by namespace. + """ + return f"_cv_utils_cuda_8cfc281::{op_name}" diff --git a/build/torch29-cxx11-cu128-aarch64-linux/cv_utils/__init__.py b/build/torch29-cxx11-cu128-aarch64-linux/cv_utils/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..03dbc1afe1cf156661a2b1b22003cd5f599a0309 --- /dev/null +++ b/build/torch29-cxx11-cu128-aarch64-linux/cv_utils/__init__.py @@ -0,0 +1,26 @@ +import ctypes +import sys + +import importlib +from pathlib import Path +from types import ModuleType + +def _import_from_path(file_path: Path) -> ModuleType: + # We cannot use the module name as-is, after adding it to `sys.modules`, + # it would also be used for other imports. So, we make a module name that + # depends on the path for it to be unique using the hex-encoded hash of + # the path. + path_hash = "{:x}".format(ctypes.c_size_t(hash(file_path.absolute())).value) + module_name = path_hash + spec = importlib.util.spec_from_file_location(module_name, file_path) + if spec is None: + raise ImportError(f"Cannot load spec for {module_name} from {file_path}") + module = importlib.util.module_from_spec(spec) + if module is None: + raise ImportError(f"Cannot load module {module_name} from spec") + sys.modules[module_name] = module + spec.loader.exec_module(module) # type: ignore + return module + + +globals().update(vars(_import_from_path(Path(__file__).parent.parent / "__init__.py"))) diff --git a/build/torch29-cxx11-cu128-aarch64-linux/metadata.json b/build/torch29-cxx11-cu128-aarch64-linux/metadata.json new file mode 100644 index 0000000000000000000000000000000000000000..e8434d821584ca7b32e25d9cda24dae18561df8b --- /dev/null +++ b/build/torch29-cxx11-cu128-aarch64-linux/metadata.json @@ -0,0 +1,20 @@ +{ + "version": 1, + "python-depends": [], + "backend": { + "type": "cuda", + "archs": [ + "10.0", + "10.1", + "12.0+PTX", + "7.0", + "7.2", + "7.5", + "8.0", + "8.6", + "8.7", + "8.9", + "9.0" + ] + } +} diff --git a/build/torch29-cxx11-cu128-x86_64-linux/__init__.py b/build/torch29-cxx11-cu128-x86_64-linux/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..578e7a4b853e2a2ab5edc3df30f794ca5f0d8f00 --- /dev/null +++ b/build/torch29-cxx11-cu128-x86_64-linux/__init__.py @@ -0,0 +1,12 @@ +import torch +from typing import List + +from ._ops import ops + +def cc_2d(inputs: torch.Tensor, get_counts: bool) -> List[torch.Tensor]: + return ops.cc_2d(inputs, get_counts) + +def generic_nms(dets: torch.Tensor, scores: torch.Tensor, iou_threshold: float, use_iou_matrix: bool) -> torch.Tensor: + return ops.generic_nms(dets, scores, iou_threshold, use_iou_matrix) + +__all__ = ["cc_2d", "generic_nms"] \ No newline at end of file diff --git a/build/torch29-cxx11-cu128-x86_64-linux/_cv_utils_cuda_8cfc281.abi3.so b/build/torch29-cxx11-cu128-x86_64-linux/_cv_utils_cuda_8cfc281.abi3.so new file mode 100644 index 0000000000000000000000000000000000000000..bb1e6f516ad3be3b80bbec18124859117843f114 --- /dev/null +++ b/build/torch29-cxx11-cu128-x86_64-linux/_cv_utils_cuda_8cfc281.abi3.so @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:6de53c33d39f86713be4b3e6e7ebf1a4f193b69fdc8fd86ce326c1514982b774 +size 3724440 diff --git a/build/torch29-cxx11-cu128-x86_64-linux/_ops.py b/build/torch29-cxx11-cu128-x86_64-linux/_ops.py new file mode 100644 index 0000000000000000000000000000000000000000..48d9641f50e19021591d4bc06f39ba88b48a9616 --- /dev/null +++ b/build/torch29-cxx11-cu128-x86_64-linux/_ops.py @@ -0,0 +1,9 @@ +import torch +from . import _cv_utils_cuda_8cfc281 +ops = torch.ops._cv_utils_cuda_8cfc281 + +def add_op_namespace_prefix(op_name: str): + """ + Prefix op by namespace. + """ + return f"_cv_utils_cuda_8cfc281::{op_name}" diff --git a/build/torch29-cxx11-cu128-x86_64-linux/cv_utils/__init__.py b/build/torch29-cxx11-cu128-x86_64-linux/cv_utils/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..03dbc1afe1cf156661a2b1b22003cd5f599a0309 --- /dev/null +++ b/build/torch29-cxx11-cu128-x86_64-linux/cv_utils/__init__.py @@ -0,0 +1,26 @@ +import ctypes +import sys + +import importlib +from pathlib import Path +from types import ModuleType + +def _import_from_path(file_path: Path) -> ModuleType: + # We cannot use the module name as-is, after adding it to `sys.modules`, + # it would also be used for other imports. So, we make a module name that + # depends on the path for it to be unique using the hex-encoded hash of + # the path. + path_hash = "{:x}".format(ctypes.c_size_t(hash(file_path.absolute())).value) + module_name = path_hash + spec = importlib.util.spec_from_file_location(module_name, file_path) + if spec is None: + raise ImportError(f"Cannot load spec for {module_name} from {file_path}") + module = importlib.util.module_from_spec(spec) + if module is None: + raise ImportError(f"Cannot load module {module_name} from spec") + sys.modules[module_name] = module + spec.loader.exec_module(module) # type: ignore + return module + + +globals().update(vars(_import_from_path(Path(__file__).parent.parent / "__init__.py"))) diff --git a/build/torch29-cxx11-cu128-x86_64-linux/metadata.json b/build/torch29-cxx11-cu128-x86_64-linux/metadata.json new file mode 100644 index 0000000000000000000000000000000000000000..e8434d821584ca7b32e25d9cda24dae18561df8b --- /dev/null +++ b/build/torch29-cxx11-cu128-x86_64-linux/metadata.json @@ -0,0 +1,20 @@ +{ + "version": 1, + "python-depends": [], + "backend": { + "type": "cuda", + "archs": [ + "10.0", + "10.1", + "12.0+PTX", + "7.0", + "7.2", + "7.5", + "8.0", + "8.6", + "8.7", + "8.9", + "9.0" + ] + } +} diff --git a/build/torch29-cxx11-cu129-aarch64-linux/__init__.py b/build/torch29-cxx11-cu129-aarch64-linux/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..578e7a4b853e2a2ab5edc3df30f794ca5f0d8f00 --- /dev/null +++ b/build/torch29-cxx11-cu129-aarch64-linux/__init__.py @@ -0,0 +1,12 @@ +import torch +from typing import List + +from ._ops import ops + +def cc_2d(inputs: torch.Tensor, get_counts: bool) -> List[torch.Tensor]: + return ops.cc_2d(inputs, get_counts) + +def generic_nms(dets: torch.Tensor, scores: torch.Tensor, iou_threshold: float, use_iou_matrix: bool) -> torch.Tensor: + return ops.generic_nms(dets, scores, iou_threshold, use_iou_matrix) + +__all__ = ["cc_2d", "generic_nms"] \ No newline at end of file diff --git a/build/torch29-cxx11-cu129-aarch64-linux/_cv_utils_cuda_d91fc8d.abi3.so b/build/torch29-cxx11-cu129-aarch64-linux/_cv_utils_cuda_d91fc8d.abi3.so new file mode 100644 index 0000000000000000000000000000000000000000..083ddc79277b9898af87b7c71d14776a4000ab1a --- /dev/null +++ b/build/torch29-cxx11-cu129-aarch64-linux/_cv_utils_cuda_d91fc8d.abi3.so @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:1e0e09c11e4b5033d3b6b53cdb230726fb96bc9f394a53b2dc466d3b40f522cf +size 3822096 diff --git a/build/torch29-cxx11-cu129-aarch64-linux/_ops.py b/build/torch29-cxx11-cu129-aarch64-linux/_ops.py new file mode 100644 index 0000000000000000000000000000000000000000..f558161b89369dd5a14b0010ec991689a086588b --- /dev/null +++ b/build/torch29-cxx11-cu129-aarch64-linux/_ops.py @@ -0,0 +1,9 @@ +import torch +from . import _cv_utils_cuda_d91fc8d +ops = torch.ops._cv_utils_cuda_d91fc8d + +def add_op_namespace_prefix(op_name: str): + """ + Prefix op by namespace. + """ + return f"_cv_utils_cuda_d91fc8d::{op_name}" diff --git a/build/torch29-cxx11-cu129-aarch64-linux/cv_utils/__init__.py b/build/torch29-cxx11-cu129-aarch64-linux/cv_utils/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..a9b2672c1cd85b74c1b3ded0fc0b2100e1aeac23 --- /dev/null +++ b/build/torch29-cxx11-cu129-aarch64-linux/cv_utils/__init__.py @@ -0,0 +1,26 @@ +import ctypes +import importlib.util +import sys +from pathlib import Path +from types import ModuleType + + +def _import_from_path(file_path: Path) -> ModuleType: + # We cannot use the module name as-is, after adding it to `sys.modules`, + # it would also be used for other imports. So, we make a module name that + # depends on the path for it to be unique using the hex-encoded hash of + # the path. + path_hash = "{:x}".format(ctypes.c_size_t(hash(file_path.absolute())).value) + module_name = path_hash + spec = importlib.util.spec_from_file_location(module_name, file_path) + if spec is None: + raise ImportError(f"Cannot load spec for {module_name} from {file_path}") + module = importlib.util.module_from_spec(spec) + if module is None: + raise ImportError(f"Cannot load module {module_name} from spec") + sys.modules[module_name] = module + spec.loader.exec_module(module) # type: ignore + return module + + +globals().update(vars(_import_from_path(Path(__file__).parent.parent / "__init__.py"))) diff --git a/build/torch29-cxx11-cu129-aarch64-linux/metadata.json b/build/torch29-cxx11-cu129-aarch64-linux/metadata.json new file mode 100644 index 0000000000000000000000000000000000000000..e8434d821584ca7b32e25d9cda24dae18561df8b --- /dev/null +++ b/build/torch29-cxx11-cu129-aarch64-linux/metadata.json @@ -0,0 +1,20 @@ +{ + "version": 1, + "python-depends": [], + "backend": { + "type": "cuda", + "archs": [ + "10.0", + "10.1", + "12.0+PTX", + "7.0", + "7.2", + "7.5", + "8.0", + "8.6", + "8.7", + "8.9", + "9.0" + ] + } +} diff --git a/build/torch29-cxx11-cu129-x86_64-linux/__init__.py b/build/torch29-cxx11-cu129-x86_64-linux/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..578e7a4b853e2a2ab5edc3df30f794ca5f0d8f00 --- /dev/null +++ b/build/torch29-cxx11-cu129-x86_64-linux/__init__.py @@ -0,0 +1,12 @@ +import torch +from typing import List + +from ._ops import ops + +def cc_2d(inputs: torch.Tensor, get_counts: bool) -> List[torch.Tensor]: + return ops.cc_2d(inputs, get_counts) + +def generic_nms(dets: torch.Tensor, scores: torch.Tensor, iou_threshold: float, use_iou_matrix: bool) -> torch.Tensor: + return ops.generic_nms(dets, scores, iou_threshold, use_iou_matrix) + +__all__ = ["cc_2d", "generic_nms"] \ No newline at end of file diff --git a/build/torch29-cxx11-cu129-x86_64-linux/_cv_utils_cuda_d91fc8d.abi3.so b/build/torch29-cxx11-cu129-x86_64-linux/_cv_utils_cuda_d91fc8d.abi3.so new file mode 100644 index 0000000000000000000000000000000000000000..a8ad1d18ee516b66589887c6cf976b58a5872467 --- /dev/null +++ b/build/torch29-cxx11-cu129-x86_64-linux/_cv_utils_cuda_d91fc8d.abi3.so @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:61220d27af0f4e81410f3211b82789b49f45cfeab97fff61f256bd260b6813b1 +size 3688568 diff --git a/build/torch29-cxx11-cu129-x86_64-linux/_ops.py b/build/torch29-cxx11-cu129-x86_64-linux/_ops.py new file mode 100644 index 0000000000000000000000000000000000000000..f558161b89369dd5a14b0010ec991689a086588b --- /dev/null +++ b/build/torch29-cxx11-cu129-x86_64-linux/_ops.py @@ -0,0 +1,9 @@ +import torch +from . import _cv_utils_cuda_d91fc8d +ops = torch.ops._cv_utils_cuda_d91fc8d + +def add_op_namespace_prefix(op_name: str): + """ + Prefix op by namespace. + """ + return f"_cv_utils_cuda_d91fc8d::{op_name}" diff --git a/build/torch29-cxx11-cu129-x86_64-linux/cv_utils/__init__.py b/build/torch29-cxx11-cu129-x86_64-linux/cv_utils/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..a9b2672c1cd85b74c1b3ded0fc0b2100e1aeac23 --- /dev/null +++ b/build/torch29-cxx11-cu129-x86_64-linux/cv_utils/__init__.py @@ -0,0 +1,26 @@ +import ctypes +import importlib.util +import sys +from pathlib import Path +from types import ModuleType + + +def _import_from_path(file_path: Path) -> ModuleType: + # We cannot use the module name as-is, after adding it to `sys.modules`, + # it would also be used for other imports. So, we make a module name that + # depends on the path for it to be unique using the hex-encoded hash of + # the path. + path_hash = "{:x}".format(ctypes.c_size_t(hash(file_path.absolute())).value) + module_name = path_hash + spec = importlib.util.spec_from_file_location(module_name, file_path) + if spec is None: + raise ImportError(f"Cannot load spec for {module_name} from {file_path}") + module = importlib.util.module_from_spec(spec) + if module is None: + raise ImportError(f"Cannot load module {module_name} from spec") + sys.modules[module_name] = module + spec.loader.exec_module(module) # type: ignore + return module + + +globals().update(vars(_import_from_path(Path(__file__).parent.parent / "__init__.py"))) diff --git a/build/torch29-cxx11-cu129-x86_64-linux/metadata.json b/build/torch29-cxx11-cu129-x86_64-linux/metadata.json new file mode 100644 index 0000000000000000000000000000000000000000..e8434d821584ca7b32e25d9cda24dae18561df8b --- /dev/null +++ b/build/torch29-cxx11-cu129-x86_64-linux/metadata.json @@ -0,0 +1,20 @@ +{ + "version": 1, + "python-depends": [], + "backend": { + "type": "cuda", + "archs": [ + "10.0", + "10.1", + "12.0+PTX", + "7.0", + "7.2", + "7.5", + "8.0", + "8.6", + "8.7", + "8.9", + "9.0" + ] + } +} diff --git a/build/torch29-cxx11-cu130-aarch64-linux/__init__.py b/build/torch29-cxx11-cu130-aarch64-linux/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..578e7a4b853e2a2ab5edc3df30f794ca5f0d8f00 --- /dev/null +++ b/build/torch29-cxx11-cu130-aarch64-linux/__init__.py @@ -0,0 +1,12 @@ +import torch +from typing import List + +from ._ops import ops + +def cc_2d(inputs: torch.Tensor, get_counts: bool) -> List[torch.Tensor]: + return ops.cc_2d(inputs, get_counts) + +def generic_nms(dets: torch.Tensor, scores: torch.Tensor, iou_threshold: float, use_iou_matrix: bool) -> torch.Tensor: + return ops.generic_nms(dets, scores, iou_threshold, use_iou_matrix) + +__all__ = ["cc_2d", "generic_nms"] \ No newline at end of file diff --git a/build/torch29-cxx11-cu130-aarch64-linux/_cv_utils_cuda_8cfc281.abi3.so b/build/torch29-cxx11-cu130-aarch64-linux/_cv_utils_cuda_8cfc281.abi3.so new file mode 100644 index 0000000000000000000000000000000000000000..43903d16981525fde7ffbfc60fa423950cc5a4fa --- /dev/null +++ b/build/torch29-cxx11-cu130-aarch64-linux/_cv_utils_cuda_8cfc281.abi3.so @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:6d3eae36344c7f1472879d5df26ad7fc9826e7ae5fd99a89114d147a015f0d5c +size 3630144 diff --git a/build/torch29-cxx11-cu130-aarch64-linux/_ops.py b/build/torch29-cxx11-cu130-aarch64-linux/_ops.py new file mode 100644 index 0000000000000000000000000000000000000000..48d9641f50e19021591d4bc06f39ba88b48a9616 --- /dev/null +++ b/build/torch29-cxx11-cu130-aarch64-linux/_ops.py @@ -0,0 +1,9 @@ +import torch +from . import _cv_utils_cuda_8cfc281 +ops = torch.ops._cv_utils_cuda_8cfc281 + +def add_op_namespace_prefix(op_name: str): + """ + Prefix op by namespace. + """ + return f"_cv_utils_cuda_8cfc281::{op_name}" diff --git a/build/torch29-cxx11-cu130-aarch64-linux/cv_utils/__init__.py b/build/torch29-cxx11-cu130-aarch64-linux/cv_utils/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..03dbc1afe1cf156661a2b1b22003cd5f599a0309 --- /dev/null +++ b/build/torch29-cxx11-cu130-aarch64-linux/cv_utils/__init__.py @@ -0,0 +1,26 @@ +import ctypes +import sys + +import importlib +from pathlib import Path +from types import ModuleType + +def _import_from_path(file_path: Path) -> ModuleType: + # We cannot use the module name as-is, after adding it to `sys.modules`, + # it would also be used for other imports. So, we make a module name that + # depends on the path for it to be unique using the hex-encoded hash of + # the path. + path_hash = "{:x}".format(ctypes.c_size_t(hash(file_path.absolute())).value) + module_name = path_hash + spec = importlib.util.spec_from_file_location(module_name, file_path) + if spec is None: + raise ImportError(f"Cannot load spec for {module_name} from {file_path}") + module = importlib.util.module_from_spec(spec) + if module is None: + raise ImportError(f"Cannot load module {module_name} from spec") + sys.modules[module_name] = module + spec.loader.exec_module(module) # type: ignore + return module + + +globals().update(vars(_import_from_path(Path(__file__).parent.parent / "__init__.py"))) diff --git a/build/torch29-cxx11-cu130-aarch64-linux/metadata.json b/build/torch29-cxx11-cu130-aarch64-linux/metadata.json new file mode 100644 index 0000000000000000000000000000000000000000..6255e63ff003b42aa6279cd430bf3bd493c6aa31 --- /dev/null +++ b/build/torch29-cxx11-cu130-aarch64-linux/metadata.json @@ -0,0 +1,18 @@ +{ + "version": 1, + "python-depends": [], + "backend": { + "type": "cuda", + "archs": [ + "10.0", + "11.0", + "12.0+PTX", + "7.5", + "8.0", + "8.6", + "8.7", + "8.9", + "9.0" + ] + } +} diff --git a/build/torch29-cxx11-cu130-x86_64-linux/__init__.py b/build/torch29-cxx11-cu130-x86_64-linux/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..578e7a4b853e2a2ab5edc3df30f794ca5f0d8f00 --- /dev/null +++ b/build/torch29-cxx11-cu130-x86_64-linux/__init__.py @@ -0,0 +1,12 @@ +import torch +from typing import List + +from ._ops import ops + +def cc_2d(inputs: torch.Tensor, get_counts: bool) -> List[torch.Tensor]: + return ops.cc_2d(inputs, get_counts) + +def generic_nms(dets: torch.Tensor, scores: torch.Tensor, iou_threshold: float, use_iou_matrix: bool) -> torch.Tensor: + return ops.generic_nms(dets, scores, iou_threshold, use_iou_matrix) + +__all__ = ["cc_2d", "generic_nms"] \ No newline at end of file diff --git a/build/torch29-cxx11-cu130-x86_64-linux/_cv_utils_cuda_8cfc281.abi3.so b/build/torch29-cxx11-cu130-x86_64-linux/_cv_utils_cuda_8cfc281.abi3.so new file mode 100644 index 0000000000000000000000000000000000000000..d34541ac788a76669bbab379e5ecc2a1c0b7c520 --- /dev/null +++ b/build/torch29-cxx11-cu130-x86_64-linux/_cv_utils_cuda_8cfc281.abi3.so @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:e6fcdb7636b87798f171c7c8675971a1df4902b1c879a1f714acda41382d94ea +size 3506472 diff --git a/build/torch29-cxx11-cu130-x86_64-linux/_ops.py b/build/torch29-cxx11-cu130-x86_64-linux/_ops.py new file mode 100644 index 0000000000000000000000000000000000000000..48d9641f50e19021591d4bc06f39ba88b48a9616 --- /dev/null +++ b/build/torch29-cxx11-cu130-x86_64-linux/_ops.py @@ -0,0 +1,9 @@ +import torch +from . import _cv_utils_cuda_8cfc281 +ops = torch.ops._cv_utils_cuda_8cfc281 + +def add_op_namespace_prefix(op_name: str): + """ + Prefix op by namespace. + """ + return f"_cv_utils_cuda_8cfc281::{op_name}" diff --git a/build/torch29-cxx11-cu130-x86_64-linux/cv_utils/__init__.py b/build/torch29-cxx11-cu130-x86_64-linux/cv_utils/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..03dbc1afe1cf156661a2b1b22003cd5f599a0309 --- /dev/null +++ b/build/torch29-cxx11-cu130-x86_64-linux/cv_utils/__init__.py @@ -0,0 +1,26 @@ +import ctypes +import sys + +import importlib +from pathlib import Path +from types import ModuleType + +def _import_from_path(file_path: Path) -> ModuleType: + # We cannot use the module name as-is, after adding it to `sys.modules`, + # it would also be used for other imports. So, we make a module name that + # depends on the path for it to be unique using the hex-encoded hash of + # the path. + path_hash = "{:x}".format(ctypes.c_size_t(hash(file_path.absolute())).value) + module_name = path_hash + spec = importlib.util.spec_from_file_location(module_name, file_path) + if spec is None: + raise ImportError(f"Cannot load spec for {module_name} from {file_path}") + module = importlib.util.module_from_spec(spec) + if module is None: + raise ImportError(f"Cannot load module {module_name} from spec") + sys.modules[module_name] = module + spec.loader.exec_module(module) # type: ignore + return module + + +globals().update(vars(_import_from_path(Path(__file__).parent.parent / "__init__.py"))) diff --git a/build/torch29-cxx11-cu130-x86_64-linux/metadata.json b/build/torch29-cxx11-cu130-x86_64-linux/metadata.json new file mode 100644 index 0000000000000000000000000000000000000000..6255e63ff003b42aa6279cd430bf3bd493c6aa31 --- /dev/null +++ b/build/torch29-cxx11-cu130-x86_64-linux/metadata.json @@ -0,0 +1,18 @@ +{ + "version": 1, + "python-depends": [], + "backend": { + "type": "cuda", + "archs": [ + "10.0", + "11.0", + "12.0+PTX", + "7.5", + "8.0", + "8.6", + "8.7", + "8.9", + "9.0" + ] + } +}