Uploaded using `kernel-builder`.

build/torch210-cxx11-cpu-x86_64-linux/__init__.py

@@ -0,0 +1,56 @@
+from typing import Optional, Tuple
+import torch
+
+from ._ops import ops
+
+
+def apply_rotary(
+    x1: torch.Tensor,
+    x2: torch.Tensor,
+    cos: torch.Tensor,
+    sin: torch.Tensor,
+    out1: torch.Tensor,
+    out2: torch.Tensor,
+    conj: bool,
+) -> None:
+    ops.apply_rotary(x1, x2, cos, sin, out1, out2, conj)
+
+
+def apply_rotary_transformers(
+    q: torch.Tensor,
+    k: torch.Tensor,
+    cos: torch.Tensor,
+    sin: torch.Tensor,
+    unsqueeze_dim: int = 1,
+) -> Tuple[torch.Tensor, torch.Tensor]:
+    """
+    Rotary kernel implementation wrapper
+    Adapts rotary kernel implementation to match transformers apply_rotary_pos_emb signature
+    """
+    cos = cos.unsqueeze(unsqueeze_dim)
+    sin = sin.unsqueeze(unsqueeze_dim)
+
+    q_rotated = q.clone()
+    k_rotated = k.clone()
+
+    # Get half dimension for rotation
+    half_dim = q.shape[-1] // 2
+    q1 = q_rotated[..., :half_dim]
+    q2 = q_rotated[..., half_dim:]
+    k1 = k_rotated[..., :half_dim]
+    k2 = k_rotated[..., half_dim:]
+    if cos.shape[-1] != half_dim:
+        # Trim cos/sin to match half_dim
+        cos = cos[..., :half_dim]
+        sin = sin[..., :half_dim]
+
+    apply_rotary(q1, q2, cos, sin, q1, q2, False)
+    apply_rotary(k1, k2, cos, sin, k1, k2, False)
+    return q_rotated, k_rotated
+
+
+# Add torch compile support for functions
+apply_rotary_transformers.can_torch_compile = True
+
+
+__all__ = ["apply_rotary", "apply_rotary_transformers"]

build/torch210-cxx11-cpu-x86_64-linux/_ops.py

@@ -0,0 +1,9 @@
+import torch
+from . import _rotary_cpu_51d8b94
+ops = torch.ops._rotary_cpu_51d8b94
+
+def add_op_namespace_prefix(op_name: str):
+    """
+    Prefix op by namespace.
+    """
+    return f"_rotary_cpu_51d8b94::{op_name}"

build/torch210-cxx11-cpu-x86_64-linux/_rotary_cpu_51d8b94.abi3.so

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:7ceffb14cf0b88800b41f1df6c4627c6f5c4fc2f90c3cf3f0d9eeb980b444403
+size 1825312

build/torch210-cxx11-cpu-x86_64-linux/metadata.json

@@ -0,0 +1,10 @@
+{
+  "name": "rotary",
+  "id": "_rotary_cpu_51d8b94",
+  "version": 1,
+  "license": "BSD-3-Clause",
+  "python-depends": [],
+  "backend": {
+    "type": "cpu"
+  }
+}

build/torch210-cxx11-cpu-x86_64-linux/metadata.json.sigstore

@@ -0,0 +1 @@
+{"mediaType":"application/vnd.dev.sigstore.bundle.v0.3+json","verificationMaterial":{"certificate":{"rawBytes":"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"},"tlogEntries":[{"logIndex":"1835475364","logId":{"keyId":"wNI9atQGlz+VWfO6LRygH4QUfY/8W4RFwiT5i5WRgB0="},"kindVersion":{"kind":"hashedrekord","version":"0.0.1"},"integratedTime":"1781598147","inclusionPromise":{"signedEntryTimestamp":"MEYCIQDJJMvriwYZkwPMGxvYVOHIXsPgGAwpmFo0JNvgmWisigIhALBlR08mDBgiHPto794bjOCT3u0RbzLJE01lurJFQObn"},"inclusionProof":{"logIndex":"1713571102","rootHash":"+byB2KyJDl7Yf4uiMWj3zKohcJ2I+9hMVwGMDj8cD2o=","treeSize":"1713571180","hashes":["gc2ScAtMIIaLhO3njy/oJ7wkbQYh9e9wFvnbHtHFRmI=","yqC9YWdSir7/AN+kRGtmsiKZYzvW1+X5FfHziJ1KezE=","mORg4eLuSoJ2TkCx3+fo3FKe7imno8dgX4OwDa6e0vg=","/OYrC+gcDNI2aGGkRVq28taisx9RStCF/g7mFibceQg=","LHBRayXoK6eKgPzEX24UOdW/NCioA3TXIfO4tpmf8Hk=","nvpWXZKULiXUU6EhxycDS2tSMlOXsLjVU7w2TucffIc=","re0qC8e/mvvmIrtVkhJrTB1FpFGt0CeL8VpsjhinGQE=","cRQMu9WbtELr7wZWtk+dF4BtyJXgRxHaCJt0Mn7ZMcs=","qyGXqH6Q4jMLTcm1FP4GC6Bq91JUZwE9FVJYSO24NOY=","QIOnO03zYXGnymwt/Tbh3DZVUKWx/SQ+zKVy7JvJNgk=","XxtFlch/wsW6OVM8HoGWrOqasE6kBErC53xEYAI8gFY=","rtCtzTK9dSsrfeeNpM2uBUGo9jofwt5LUPlnjUKF+uA=","72FC5FYLhxB4a4iiC956o0B/fT54ip4R41vsw2QBKtU=","lYGQ9ibwC8+smMkPQ6TchJm3H9Nc/aTYLfdRacGFChw=","daxmZaajRpZV+JxHiOYZhJBiSKN5ucqjh2WnGbHhirw=","DOCeoSMovIvLExkhIvisow9AuNXgeWs4ECkyR6EcqYU="],"checkpoint":{"envelope":"rekor.sigstore.dev - 1193050959916656506\n1713571180\n+byB2KyJDl7Yf4uiMWj3zKohcJ2I+9hMVwGMDj8cD2o=\n\n— rekor.sigstore.dev wNI9ajBFAiEAyz57dgaA/VyHDi9tiCJM3ssj/g4paWZLztyYFX0AC4MCIGX/MOxdPw/uN0HkOIUJviszwfy61Pa3f23x4IztPjeO\n"}},"canonicalizedBody":"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"}],"timestampVerificationData":{"rfc3161Timestamps":[{"signedTimestamp":"MIICyTADAgEAMIICwAYJKoZIhvcNAQcCoIICsTCCAq0CAQMxDTALBglghkgBZQMEAgEwgbcGCyqGSIb3DQEJEAEEoIGnBIGkMIGhAgEBBgkrBgEEAYO/MAIwMTANBglghkgBZQMEAgEFAAQgODZ4WW4WOCdTSCIDBjU6lwBbOI8pXrzYG6mTAsRGoPMCFBaBkFrQgklgxi7cTcVebUrpUMZnGA8yMDI2MDYxNjA4MjIyN1owAwIBAaAypDAwLjEVMBMGA1UEChMMc2lnc3RvcmUuZGV2MRUwEwYDVQQDEwxzaWdzdG9yZS10c2GgADGCAdswggHXAgEBMFEwOTEVMBMGA1UEChMMc2lnc3RvcmUuZGV2MSAwHgYDVQQDExdzaWdzdG9yZS10c2Etc2VsZnNpZ25lZAIUOhNULwyQYe68wUMvy4qOiyojiwwwCwYJYIZIAWUDBAIBoIH8MBoGCSqGSIb3DQEJAzENBgsqhkiG9w0BCRABBDAcBgkqhkiG9w0BCQUxDxcNMjYwNjE2MDgyMjI3WjAvBgkqhkiG9w0BCQQxIgQgrrr1Ksxu+xhqUOjYvRhtHkDbGlpBUrzMnG3XylPkhUEwgY4GCyqGSIb3DQEJEAIvMX8wfTB7MHkEIIX5J7wHq2LKw7RDVsEO/IGyxog/2nq55thw2dE6zQW3MFUwPaQ7MDkxFTATBgNVBAoTDHNpZ3N0b3JlLmRldjEgMB4GA1UEAxMXc2lnc3RvcmUtdHNhLXNlbGZzaWduZWQCFDoTVC8MkGHuvMFDL8uKjosqI4sMMAoGCCqGSM49BAMCBGcwZQIxAJ5mW48TlvxvMdwzjVJ0E2Wwqk099eaZS0cfGdNvmzdNZ76jvdzYOBd913ZXw+ldEAIweK6zXH4qRcAoZqUep8wGhTvKisqC08qWiwb3+W6gUM7TG3Nq3jfMTPoIfA5ulkx5"}]}},"messageSignature":{"messageDigest":{"algorithm":"SHA2_256","digest":"KENe1N0OzuUh36RIOLjVutcQYgsyRJwefJH8nRm8GkM="},"signature":"MEUCIHBZSIlgs7Bk/BfugsQg2K5Aua4G5cdBbtJvhSNh4kOJAiEAwrg9IVTCpgEoNH7ALbYn1eMvRemNJ+nJJHbKFD+cDXY="}}

build/torch210-cxx11-cpu-x86_64-linux/rotary/__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")))

build/torch211-cxx11-cpu-x86_64-linux/__init__.py

@@ -0,0 +1,56 @@
+from typing import Optional, Tuple
+import torch
+
+from ._ops import ops
+
+
+def apply_rotary(
+    x1: torch.Tensor,
+    x2: torch.Tensor,
+    cos: torch.Tensor,
+    sin: torch.Tensor,
+    out1: torch.Tensor,
+    out2: torch.Tensor,
+    conj: bool,
+) -> None:
+    ops.apply_rotary(x1, x2, cos, sin, out1, out2, conj)
+
+
+def apply_rotary_transformers(
+    q: torch.Tensor,
+    k: torch.Tensor,
+    cos: torch.Tensor,
+    sin: torch.Tensor,
+    unsqueeze_dim: int = 1,
+) -> Tuple[torch.Tensor, torch.Tensor]:
+    """
+    Rotary kernel implementation wrapper
+    Adapts rotary kernel implementation to match transformers apply_rotary_pos_emb signature
+    """
+    cos = cos.unsqueeze(unsqueeze_dim)
+    sin = sin.unsqueeze(unsqueeze_dim)
+
+    q_rotated = q.clone()
+    k_rotated = k.clone()
+
+    # Get half dimension for rotation
+    half_dim = q.shape[-1] // 2
+    q1 = q_rotated[..., :half_dim]
+    q2 = q_rotated[..., half_dim:]
+    k1 = k_rotated[..., :half_dim]
+    k2 = k_rotated[..., half_dim:]
+    if cos.shape[-1] != half_dim:
+        # Trim cos/sin to match half_dim
+        cos = cos[..., :half_dim]
+        sin = sin[..., :half_dim]
+
+    apply_rotary(q1, q2, cos, sin, q1, q2, False)
+    apply_rotary(k1, k2, cos, sin, k1, k2, False)
+    return q_rotated, k_rotated
+
+
+# Add torch compile support for functions
+apply_rotary_transformers.can_torch_compile = True
+
+
+__all__ = ["apply_rotary", "apply_rotary_transformers"]

build/torch211-cxx11-cpu-x86_64-linux/_ops.py

@@ -0,0 +1,9 @@
+import torch
+from . import _rotary_cpu_51d8b94
+ops = torch.ops._rotary_cpu_51d8b94
+
+def add_op_namespace_prefix(op_name: str):
+    """
+    Prefix op by namespace.
+    """
+    return f"_rotary_cpu_51d8b94::{op_name}"

build/torch211-cxx11-cpu-x86_64-linux/_rotary_cpu_51d8b94.abi3.so

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:4a3cbf44e4ba3eb994edbe741d9c83f0bb704ac548f8222301cb6dd249924347
+size 1825312

build/torch211-cxx11-cpu-x86_64-linux/metadata.json

@@ -0,0 +1,10 @@
+{
+  "name": "rotary",
+  "id": "_rotary_cpu_51d8b94",
+  "version": 1,
+  "license": "BSD-3-Clause",
+  "python-depends": [],
+  "backend": {
+    "type": "cpu"
+  }
+}

build/torch211-cxx11-cpu-x86_64-linux/metadata.json.sigstore

@@ -0,0 +1 @@
+{"mediaType":"application/vnd.dev.sigstore.bundle.v0.3+json","verificationMaterial":{"certificate":{"rawBytes":"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"},"tlogEntries":[{"logIndex":"1835475647","logId":{"keyId":"wNI9atQGlz+VWfO6LRygH4QUfY/8W4RFwiT5i5WRgB0="},"kindVersion":{"kind":"hashedrekord","version":"0.0.1"},"integratedTime":"1781598148","inclusionPromise":{"signedEntryTimestamp":"MEUCIQCiw1ZLJ8WHk0Y6qq5wFRozVSmxONuSKlC35emgkMiPngIgX1M3gCKIxQAvNbzvkXrl9Muxguv4OBhVQgZfp3LUTng="},"inclusionProof":{"logIndex":"1713571385","rootHash":"iMFphK74qBKrltIsugwqc87Ag41m2/1GKe59ursFxjY=","treeSize":"1713571390","hashes":["Zw2/Br8wodVFP3taRd7E7cbwer4J+bHxUa6DsmZRZY8=","mm5vJTfSaqsZiM1GMMQ+XB+tJDJjgFMrO2ORY/JpRIw=","KJ74Bq312Ct7dPo9g5rjzIOGU4XHIX1k7qSyiw/5jAA=","duEIdHqQLCQdXK+MuGDXqBdH5eUsFgE8CoG0Z/olgsA=","tg09jQAEfd4PV8X2cKgRn64VhyTLGgC8SKwLAkKvYXI=","O5Fz5IGOZuTj+PRWRHMmm4elpH0DGlb0fEYYwTMgEBQ=","xFkbYO8XwojjkwxJ2WGLXPDkroWU9TBJS6X4Zit67Sw=","qyGXqH6Q4jMLTcm1FP4GC6Bq91JUZwE9FVJYSO24NOY=","QIOnO03zYXGnymwt/Tbh3DZVUKWx/SQ+zKVy7JvJNgk=","XxtFlch/wsW6OVM8HoGWrOqasE6kBErC53xEYAI8gFY=","rtCtzTK9dSsrfeeNpM2uBUGo9jofwt5LUPlnjUKF+uA=","72FC5FYLhxB4a4iiC956o0B/fT54ip4R41vsw2QBKtU=","lYGQ9ibwC8+smMkPQ6TchJm3H9Nc/aTYLfdRacGFChw=","daxmZaajRpZV+JxHiOYZhJBiSKN5ucqjh2WnGbHhirw=","DOCeoSMovIvLExkhIvisow9AuNXgeWs4ECkyR6EcqYU="],"checkpoint":{"envelope":"rekor.sigstore.dev - 1193050959916656506\n1713571390\niMFphK74qBKrltIsugwqc87Ag41m2/1GKe59ursFxjY=\n\n— rekor.sigstore.dev wNI9ajBEAiBoS67GblI1J1R6AIQyRA0Nwg9hp8a6cTzRFQIS6iUGGAIgcEkd9cHOjdjDtOPAxCMuo3/tXa22guXRzKX1frSYTwE=\n"}},"canonicalizedBody":"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"}],"timestampVerificationData":{"rfc3161Timestamps":[{"signedTimestamp":"MIICyTADAgEAMIICwAYJKoZIhvcNAQcCoIICsTCCAq0CAQMxDTALBglghkgBZQMEAgEwgbgGCyqGSIb3DQEJEAEEoIGoBIGlMIGiAgEBBgkrBgEEAYO/MAIwMTANBglghkgBZQMEAgEFAAQgkxEKHsfXFBCVvVI9Ill3mbfe0M8fT2SbopNLnGjakosCFQDcNlLIek9Wv7+p+pyZLTHXsLx5YRgPMjAyNjA2MTYwODIyMjhaMAMCAQGgMqQwMC4xFTATBgNVBAoTDHNpZ3N0b3JlLmRldjEVMBMGA1UEAxMMc2lnc3RvcmUtdHNhoAAxggHaMIIB1gIBATBRMDkxFTATBgNVBAoTDHNpZ3N0b3JlLmRldjEgMB4GA1UEAxMXc2lnc3RvcmUtdHNhLXNlbGZzaWduZWQCFDoTVC8MkGHuvMFDL8uKjosqI4sMMAsGCWCGSAFlAwQCAaCB/DAaBgkqhkiG9w0BCQMxDQYLKoZIhvcNAQkQAQQwHAYJKoZIhvcNAQkFMQ8XDTI2MDYxNjA4MjIyOFowLwYJKoZIhvcNAQkEMSIEIEYf1gBcXpKa+MLpPRjKrDu7djKfBOlAYFJ/ug0FgkWtMIGOBgsqhkiG9w0BCRACLzF/MH0wezB5BCCF+Se8B6tiysO0Q1bBDvyBssaIP9p6uebYcNnROs0FtzBVMD2kOzA5MRUwEwYDVQQKEwxzaWdzdG9yZS5kZXYxIDAeBgNVBAMTF3NpZ3N0b3JlLXRzYS1zZWxmc2lnbmVkAhQ6E1QvDJBh7rzBQy/Lio6LKiOLDDAKBggqhkjOPQQDAgRmMGQCMHMYuyqx/WtCA4pEgrhGijIt3P4eQG+YRyxhJ7K7kkLE1EkYkqdl2x9TWJ/8+hxMGwIwAg5lGC4asNvwM8qwyr3XOLj6IfjZ5P6s2d5HOKOpVV/hkMFoTnB05pmhMJ/hlvpL"}]}},"messageSignature":{"messageDigest":{"algorithm":"SHA2_256","digest":"KENe1N0OzuUh36RIOLjVutcQYgsyRJwefJH8nRm8GkM="},"signature":"MEUCICkLQCosV+VKz6CTgM8tUNKmSKnOhB/OCJeMehJKUv8fAiEA5ixMu4k8lyNFabJI51HfUkGWULxsRbuXVNuWozJ072Q="}}

build/torch211-cxx11-cpu-x86_64-linux/rotary/__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")))

build/torch212-cxx11-cpu-x86_64-linux/__init__.py

@@ -0,0 +1,56 @@
+from typing import Optional, Tuple
+import torch
+
+from ._ops import ops
+
+
+def apply_rotary(
+    x1: torch.Tensor,
+    x2: torch.Tensor,
+    cos: torch.Tensor,
+    sin: torch.Tensor,
+    out1: torch.Tensor,
+    out2: torch.Tensor,
+    conj: bool,
+) -> None:
+    ops.apply_rotary(x1, x2, cos, sin, out1, out2, conj)
+
+
+def apply_rotary_transformers(
+    q: torch.Tensor,
+    k: torch.Tensor,
+    cos: torch.Tensor,
+    sin: torch.Tensor,
+    unsqueeze_dim: int = 1,
+) -> Tuple[torch.Tensor, torch.Tensor]:
+    """
+    Rotary kernel implementation wrapper
+    Adapts rotary kernel implementation to match transformers apply_rotary_pos_emb signature
+    """
+    cos = cos.unsqueeze(unsqueeze_dim)
+    sin = sin.unsqueeze(unsqueeze_dim)
+
+    q_rotated = q.clone()
+    k_rotated = k.clone()
+
+    # Get half dimension for rotation
+    half_dim = q.shape[-1] // 2
+    q1 = q_rotated[..., :half_dim]
+    q2 = q_rotated[..., half_dim:]
+    k1 = k_rotated[..., :half_dim]
+    k2 = k_rotated[..., half_dim:]
+    if cos.shape[-1] != half_dim:
+        # Trim cos/sin to match half_dim
+        cos = cos[..., :half_dim]
+        sin = sin[..., :half_dim]
+
+    apply_rotary(q1, q2, cos, sin, q1, q2, False)
+    apply_rotary(k1, k2, cos, sin, k1, k2, False)
+    return q_rotated, k_rotated
+
+
+# Add torch compile support for functions
+apply_rotary_transformers.can_torch_compile = True
+
+
+__all__ = ["apply_rotary", "apply_rotary_transformers"]

build/torch212-cxx11-cpu-x86_64-linux/_ops.py

@@ -0,0 +1,9 @@
+import torch
+from . import _rotary_cpu_51d8b94
+ops = torch.ops._rotary_cpu_51d8b94
+
+def add_op_namespace_prefix(op_name: str):
+    """
+    Prefix op by namespace.
+    """
+    return f"_rotary_cpu_51d8b94::{op_name}"

build/torch212-cxx11-cpu-x86_64-linux/_rotary_cpu_51d8b94.abi3.so

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b30823f9eb30185284ede8d78e6b7e40c7ebe4fcc36ce9be575b43a921a2bfdc
+size 1825320

build/torch212-cxx11-cpu-x86_64-linux/metadata.json

@@ -0,0 +1,10 @@
+{
+  "name": "rotary",
+  "id": "_rotary_cpu_51d8b94",
+  "version": 1,
+  "license": "BSD-3-Clause",
+  "python-depends": [],
+  "backend": {
+    "type": "cpu"
+  }
+}

build/torch212-cxx11-cpu-x86_64-linux/metadata.json.sigstore

@@ -0,0 +1 @@
+{"mediaType":"application/vnd.dev.sigstore.bundle.v0.3+json","verificationMaterial":{"certificate":{"rawBytes":"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"},"tlogEntries":[{"logIndex":"1835475887","logId":{"keyId":"wNI9atQGlz+VWfO6LRygH4QUfY/8W4RFwiT5i5WRgB0="},"kindVersion":{"kind":"hashedrekord","version":"0.0.1"},"integratedTime":"1781598150","inclusionPromise":{"signedEntryTimestamp":"MEUCIF4KmQBInTNOir7KB4gRBvlr/BTYiNffernh3l9dIFQYAiEA+qFAN5eW8JK0mcDfSGvianmzJNTwpc/sBNO0FUj5b1Q="},"inclusionProof":{"logIndex":"1713571625","rootHash":"Z5XudkMtnp+f5a0TW69hqT8HhT55oofsf2HHKemJcEM=","treeSize":"1713571628","hashes":["1eVyEZ9u2smHGekPgg+Pj2QQE98AVCEkxYR1K7WSO08=","AUigaBbZyqVZSo619HSMM1faHC+5hRqbxKIMwpKmtsI=","oFyoN+1iRgSV2+YaqG8CIialDep1Bae8K2juLTfFibI=","2Qzcyf69nYvnsR3WbIE3DHblvczXKYmOQYQLrP7vfUs=","wxYR+ehm6gmbVifgtXLrVPiLhvVQuzGfw0srO+8vyDI=","xFkbYO8XwojjkwxJ2WGLXPDkroWU9TBJS6X4Zit67Sw=","qyGXqH6Q4jMLTcm1FP4GC6Bq91JUZwE9FVJYSO24NOY=","QIOnO03zYXGnymwt/Tbh3DZVUKWx/SQ+zKVy7JvJNgk=","XxtFlch/wsW6OVM8HoGWrOqasE6kBErC53xEYAI8gFY=","rtCtzTK9dSsrfeeNpM2uBUGo9jofwt5LUPlnjUKF+uA=","72FC5FYLhxB4a4iiC956o0B/fT54ip4R41vsw2QBKtU=","lYGQ9ibwC8+smMkPQ6TchJm3H9Nc/aTYLfdRacGFChw=","daxmZaajRpZV+JxHiOYZhJBiSKN5ucqjh2WnGbHhirw=","DOCeoSMovIvLExkhIvisow9AuNXgeWs4ECkyR6EcqYU="],"checkpoint":{"envelope":"rekor.sigstore.dev - 1193050959916656506\n1713571628\nZ5XudkMtnp+f5a0TW69hqT8HhT55oofsf2HHKemJcEM=\n\n— rekor.sigstore.dev wNI9ajBFAiA2bnuVQE7gt3Q5Sc93tCuI1xt5V5ka6ktxhfZkhXDTUwIhAIQepdSIEBdWnjXi7xMstqUETgl06ljFiiS/CDOQ+gJS\n"}},"canonicalizedBody":"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"}],"timestampVerificationData":{"rfc3161Timestamps":[{"signedTimestamp":"MIICyjADAgEAMIICwQYJKoZIhvcNAQcCoIICsjCCAq4CAQMxDTALBglghkgBZQMEAgEwgbgGCyqGSIb3DQEJEAEEoIGoBIGlMIGiAgEBBgkrBgEEAYO/MAIwMTANBglghkgBZQMEAgEFAAQgiv/SwGF+xwKbcBQD90Z+I4VdoUeRWQ6qCqQG1yxFwVkCFQC8iHeUm5UkuVO7+VT8Vipsov2YQRgPMjAyNjA2MTYwODIyMzBaMAMCAQGgMqQwMC4xFTATBgNVBAoTDHNpZ3N0b3JlLmRldjEVMBMGA1UEAxMMc2lnc3RvcmUtdHNhoAAxggHbMIIB1wIBATBRMDkxFTATBgNVBAoTDHNpZ3N0b3JlLmRldjEgMB4GA1UEAxMXc2lnc3RvcmUtdHNhLXNlbGZzaWduZWQCFDoTVC8MkGHuvMFDL8uKjosqI4sMMAsGCWCGSAFlAwQCAaCB/DAaBgkqhkiG9w0BCQMxDQYLKoZIhvcNAQkQAQQwHAYJKoZIhvcNAQkFMQ8XDTI2MDYxNjA4MjIzMFowLwYJKoZIhvcNAQkEMSIEID4g/00PdzVN+mu8INkCO/xXnt2ASxKoSMvBcKvq4Kz6MIGOBgsqhkiG9w0BCRACLzF/MH0wezB5BCCF+Se8B6tiysO0Q1bBDvyBssaIP9p6uebYcNnROs0FtzBVMD2kOzA5MRUwEwYDVQQKEwxzaWdzdG9yZS5kZXYxIDAeBgNVBAMTF3NpZ3N0b3JlLXRzYS1zZWxmc2lnbmVkAhQ6E1QvDJBh7rzBQy/Lio6LKiOLDDAKBggqhkjOPQQDAgRnMGUCMDYTqxsiF71cUkN+Uvr4zXaBK7it5YGhF3jjuLYpIcFlugCkr2nvpFttzHYLKLC4/QIxANRiSaiLftKyqAlTrC6rmTb7RjCQQSdFLXMf5jhTVBK8OaMUhmju0Y5RZjAVVOIP1w=="}]}},"messageSignature":{"messageDigest":{"algorithm":"SHA2_256","digest":"KENe1N0OzuUh36RIOLjVutcQYgsyRJwefJH8nRm8GkM="},"signature":"MEYCIQCDVvsrmE5wvk3QFECymh7gm2oCI7fvAwmncQq9Nk2VJAIhAMxPSub7XK8N/4upJk6kj6aI6X5Erg6aHwswdmUKNcu2"}}

build/torch212-cxx11-cpu-x86_64-linux/rotary/__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")))