sia-script 1.0.3__tar.gz → 1.3.0__tar.gz

{sia_script-1.0.3/sia_script.egg-info → sia_script-1.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sia-script
-Version: 1.0.3
+Version: 1.3.0
 Summary: SIA — Simplified Integrated Architecture: SiaNTT, SIA-ELS (ABAP interpreter), the HDQS server client, and hdqs_engine (offline statevector quantum simulator — no server or API token required)
 Author-email: Sia Software Innovations Private Limited <info@siasoftwareinnovations.com>
 License: # PROPRIETARY SOFTWARE LICENSE

{sia_script-1.0.3 → sia_script-1.3.0}/pyproject.toml

@@ -1,10 +1,10 @@
 [build-system]
-requires = ["setuptools>=61.0", "wheel", "pybind11>=2.11"]
+requires = ["setuptools>=61.0", "wheel"]
 build-backend = "setuptools.build_meta"
 
 [project]
 name = "sia-script"
-version = "1.0.3"
+version = "1.3.0"
 description = "SIA — Simplified Integrated Architecture: SiaNTT, SIA-ELS (ABAP interpreter), the HDQS server client, and hdqs_engine (offline statevector quantum simulator — no server or API token required)"
 authors = [
     { name = "Sia Software Innovations Private Limited", email = "info@siasoftwareinnovations.com" }
@@ -62,7 +62,8 @@ client = []
 # numpy is now a base dependency; kept as an empty extra for backward
 # compatibility with anyone depending on sia-script[engine].
 engine = []
-# sia.hdqs_engine.torch_layer — trainable QuantumLayer nn.Module.
+# sia.hdqs_engine.torch_layer — trainable QuantumLayer/BackpropQuantumLayer/
+# MidCircuitQuantumLayer/QASMQuantumLayer (nn.Module).
 torch = [
     "torch>=2.0",
 ]
@@ -80,4 +81,4 @@ full = [
 packages = ["sia"]
 
 [tool.setuptools.package-data]
-"sia" = ["*.py"]
+"sia" = ["*.py"]

{sia_script-1.0.3 → sia_script-1.3.0}/sia/__init__.py

@@ -36,13 +36,8 @@ Client-side package. Loads:
                aliases, register/slice broadcasting, reset/barrier/end,
                and if/else and switch branching on measured bits.
                Requires the `openqasm3[parser]` extra.
-               Optional native (C++) acceleration for the statevector
-               gate-application hot path, with hand-vectorized AVX2/
-               AVX-512 kernels where available and automatic fallback to
-               pure NumPy on platforms without a compiled extension for
-               this build (see `sia.hdqs_engine._NATIVE_AVAILABLE`) --
-               a pure performance path, validated to produce identical
-               results to the NumPy path.
+               Pure Python (NumPy + optional PyTorch) — no compiled
+               extension, no build step, works on any platform.
                MIT-licensed (see the MIT_LICENSE string in sia/hdqs_engine.py),
                distinct from the proprietary license covering the rest of
                this package.
@@ -53,7 +48,7 @@ this client package. They live in the server deployment only. What you get
 here for local, offline quantum simulation is sia.hdqs_engine.
 """
 
-__version__ = "1.0.0"
+__version__ = "1.3.0"
 __author__ = "Sia Software Innovations Private Limited"
 # NOTE: hardcoding a bare IP couples every released client to one host. If
 # the server ever moves, every installed copy breaks. Prefer a DNS name
@@ -194,6 +189,7 @@ try:
     from .hdqs_engine import (
         # Core class (renamed from StatevectorEngine)
         HDQS,
+        PI,
         GATES,
         controlled,
         random_state,
@@ -265,6 +261,7 @@ except ImportError as _engine_import_error:
     _warnings.warn(f"sia.hdqs_engine unavailable: {_engine_import_error}",
                    ImportWarning)
     HDQS = None
+    PI = None
     StatevectorEngine = None
     GATES = None
     controlled = None
@@ -371,6 +368,7 @@ __all__ = [
     # HDQS-Engine (offline, no server/token required)
     # Core class (renamed for cleaner API)
     "HDQS",
+    "PI",
     "StatevectorEngine",  # Legacy alias for backward compatibility
     "GATES",
     "controlled",

{sia_script-1.0.3 → sia_script-1.3.0}/sia/hdqs_engine.py

@@ -2,13 +2,9 @@
 sia.hdqs_engine — offline quantum simulator with automatic GPU support
 ================================================================================
 
-Version 1.0.0 — adds an optional native (C++) acceleration core for the
-statevector hot path (h/x/y/z/rx/ry/rz/p/u3/cnot/cz/cy/cp/crx/cry/crz/swap,
-plus a general small-k kernel covering ccx/mcx/cswap and gate fusion
-flushes), hand-vectorized with AVX2 and AVX-512 (FMA-based complex
-multiply) where available, with automatic fallback to portable NumPy if
-the compiled extension isn't present for a given platform -- see
-``_NATIVE_AVAILABLE``. Also adds OpenQASM 3 import/export
+Version 1.1.0 — pure Python (NumPy + optional PyTorch) implementation.
+No compiled extension, no build step -- `pip install`/`import` and it
+works, on any platform. Adds OpenQASM 3 import/export
 (``HDQS.from_qasm3``/``to_qasm3``, tier 1+2: constants, for-loops, custom
 gate inlining, gate modifiers, switch/case, aliasing), a
 mid-circuit-measurement-aware batched trainable layer
@@ -33,13 +29,6 @@ Conventions
   unavailable); ``use_gpu=False`` forces the NumPy backend. ``device=``
   overrides for power users (e.g. device='cpu' runs the PyTorch backend on
   CPU — same code path as CUDA, useful for testing).
-* Native acceleration (optional): when the compiled ``hdqs_core`` extension
-  is importable, statevector gate application routes through it instead of
-  NumPy's einsum-based path. This is a pure performance path -- results
-  are validated identical to the NumPy path across hundreds of randomized
-  circuits per release, covering every gate family including asymmetric
-  multi-qubit matrices (cswap). No behavior changes based on whether the
-  extension is present; only speed does.
 
 Changelog v0.4.0 (from v0.3.0)
 ------------------------------
@@ -85,7 +74,9 @@ from typing import (Any, Callable, Dict, Iterable, List, Optional, Sequence,
 
 import numpy as np
 
-__version__ = "1.0.0"
+__version__ = "1.3.0"
+
+PI = np.pi  # convenience alias — HDQS(1).rx(0, PI/2) instead of np.pi/2
 
 # ==========================================================================
 
@@ -175,28 +166,6 @@ except ImportError:
     pass
 
 
-# --------------------------------------------------------------------------
-# Native (C++) kernel detection. Optional: this module works fully on pure
-# NumPy without it. When present, the statevector gate-application and
-# single-qubit-Kraus-channel hot paths route through compiled kernels
-# instead of NumPy's einsum/moveaxis dispatch (which dominates per-gate
-# overhead — profiling showed ~70% of time in bookkeeping, not arithmetic).
-# Measured: ~5-25x faster on statevector gates, ~4-12x faster on Kraus
-# channels, scaling up with qubit count, single-threaded.
-# --------------------------------------------------------------------------
-_NATIVE_AVAILABLE = False
-_hdqs_native = None
-try:
-    from . import hdqs_core as _hdqs_native  # noqa: F401
-    _NATIVE_AVAILABLE = True
-except ImportError:
-    try:
-        import hdqs_core as _hdqs_native  # noqa: F401  (standalone/dev use)
-        _NATIVE_AVAILABLE = True
-    except ImportError:
-        pass
-
-
 def is_tensor(arr: Any) -> bool:
     """True iff *arr* is a PyTorch tensor. Safe when torch is not installed
     (v0.3.0 raised NameError here, making the module unusable without torch)."""
@@ -613,6 +582,15 @@ class HDQS:
             "readout_error": readout_error_channel,
         }
 
+    @classmethod
+    def dm(cls, num_qubits: int, **kwargs) -> "HDQS":
+        """Alternative constructor for density-matrix mode: behaviorally
+        identical to HDQS(num_qubits, use_density_matrix=True, **kwargs),
+        including every other constructor argument (seed, use_gpu,
+        device). The use_density_matrix=True keyword form remains fully
+        supported -- this is an additional spelling, not a replacement."""
+        return cls(num_qubits, use_density_matrix=True, **kwargs)
+
     # -- backend helpers ------------------------------------------------------
 
     def _to_backend(self, arr):
@@ -802,27 +780,6 @@ class HDQS:
             raise ValueError(
                 f"unitary shape {U.shape} does not match {k} target(s)")
         n = self.num_qubits
-        if (not self._use_density_matrix and _NATIVE_AVAILABLE
-                and not self._backend_torch):
-            bitpos = [n - 1 - t for t in targets]
-            if k == 1:
-                sv = np.ascontiguousarray(self._sv, dtype=complex)
-                _hdqs_native.apply_1q(sv, bitpos[0],
-                                      U[0, 0], U[0, 1], U[1, 0], U[1, 1])
-                self._sv = sv
-                return self
-            if k == 2 and np.array_equal(U, _SWAP_MATRIX):
-                sv = np.ascontiguousarray(self._sv, dtype=complex)
-                _hdqs_native.apply_swap(sv, bitpos[0], bitpos[1])
-                self._sv = sv
-                return self
-            sv = np.ascontiguousarray(self._sv, dtype=complex)
-            if k <= 4:
-                _hdqs_native.apply_gate_fast(sv, bitpos, U)
-            else:
-                _hdqs_native.apply_gate(sv, bitpos, U, [])
-            self._sv = sv
-            return self
         Ub = self._to_backend(U)
         xp = self._xp
         if not self._use_density_matrix:
@@ -843,37 +800,6 @@ class HDQS:
                           target: int) -> "HDQS":
         """Apply single-qubit U to *target* conditioned on all controls = 1."""
         controls = list(controls)
-        if (not self._use_density_matrix and _NATIVE_AVAILABLE
-                and not self._backend_torch):
-            U = np.asarray(U, dtype=complex)
-            # The native kernel takes an explicit control list, so a
-            # multi-controlled gate (mcx with many controls, crz, ...)
-            # never needs the 2^(k+1)x2^(k+1) padded-identity matrix the
-            # NumPy path below has to materialize -- this is an
-            # algorithmic win, not just a constant-factor one.
-            n = self.num_qubits
-            bit_target = [n - 1 - target]
-            bit_controls = [n - 1 - c for c in controls]
-            if len(controls) == 1 and np.array_equal(U, _X):
-                # pure index-swap, no arithmetic -- fastest path for the
-                # single most common 2-qubit gate
-                sv = np.ascontiguousarray(self._sv, dtype=complex)
-                _hdqs_native.apply_cnot_fast(sv, bit_controls[0], bit_target[0])
-                self._sv = sv
-                return self
-            if len(controls) == 1:
-                # covers cy/cz/cp/crx/cry/crz -- any single-control,
-                # single-target gate with an arbitrary 2x2 U
-                sv = np.ascontiguousarray(self._sv, dtype=complex)
-                _hdqs_native.apply_controlled_1q(
-                    sv, bit_controls[0], bit_target[0],
-                    U[0, 0], U[0, 1], U[1, 0], U[1, 1])
-                self._sv = sv
-                return self
-            sv = np.ascontiguousarray(self._sv, dtype=complex)
-            _hdqs_native.apply_gate(sv, bit_target, U, bit_controls)
-            self._sv = sv
-            return self
         full = np.eye(2 ** (len(controls) + 1), dtype=complex)
         full[-2:, -2:] = np.asarray(U, dtype=complex)
         # target=LSB, controls=upper bits (see _apply_matrix_on_axes's
@@ -904,13 +830,6 @@ class HDQS:
                 f"{name}: Kraus dimension {ks[0].shape[0]} does not match "
                 f"{k} target qubit(s)")
         n = self.num_qubits
-        if k == 1 and _NATIVE_AVAILABLE and not self._backend_torch:
-            bitpos = n - 1 - targets[0]
-            rho = np.ascontiguousarray(self._rho, dtype=complex)
-            _hdqs_native.apply_kraus_1q(rho, n, bitpos, ks)
-            self._rho = _renormalize_rho(rho)
-            self._is_pure = self._check_purity()
-            return self
         xp = self._xp
         T = self._rho.reshape((2,) * (2 * n))
         col_axes = [n + t for t in targets]
@@ -938,8 +857,22 @@ class HDQS:
 
     # -- single-qubit gates ---------------------------------------------------
 
-    def h(self, q: int) -> "HDQS":
-        return self._apply_unitary(_H, [q])
+    def _resolve_optional_qubit(self, q: Optional[int]) -> int:
+        """Resolve an omitted qubit index for the zero-parameter single-qubit
+        gates (h/x/y/z/s/sdg/t/tdg) to the sole qubit of a 1-qubit register.
+        Deliberately not extended to angle-parameter gates (rx/ry/rz/p/u3):
+        making their qubit index optional would require either reordering
+        their argument list or making the angle keyword-only, either of
+        which breaks existing call sites. Ambiguity always raises rather
+        than silently defaulting."""
+        if q is not None:
+            return q
+        if self.num_qubits != 1:
+            raise ValueError(
+                "qubit index is required when the register has more than "
+                f"one qubit ({self.num_qubits} qubits here); only a "
+                "1-qubit register can omit it")
+        return 0
 
     # -- circuit logging --------------------------------------------------
 
@@ -955,42 +888,50 @@ class HDQS:
 
     # -- single-qubit gates -----------------------------------------------
 
-    def h(self, q: int) -> "HDQS":
+    def h(self, q: Optional[int] = None) -> "HDQS":
+        q = self._resolve_optional_qubit(q)
         self._log(f"H({q})")
         self._ops.append(("h", [q], []))
         return self._apply_unitary(_H, [q])
 
-    def x(self, q: int) -> "HDQS":
+    def x(self, q: Optional[int] = None) -> "HDQS":
+        q = self._resolve_optional_qubit(q)
         self._log(f"X({q})")
         self._ops.append(("x", [q], []))
         return self._apply_unitary(_X, [q])
 
-    def y(self, q: int) -> "HDQS":
+    def y(self, q: Optional[int] = None) -> "HDQS":
+        q = self._resolve_optional_qubit(q)
         self._log(f"Y({q})")
         self._ops.append(("y", [q], []))
         return self._apply_unitary(_Y, [q])
 
-    def z(self, q: int) -> "HDQS":
+    def z(self, q: Optional[int] = None) -> "HDQS":
+        q = self._resolve_optional_qubit(q)
         self._log(f"Z({q})")
         self._ops.append(("z", [q], []))
         return self._apply_unitary(_Z, [q])
 
-    def s(self, q: int) -> "HDQS":
+    def s(self, q: Optional[int] = None) -> "HDQS":
+        q = self._resolve_optional_qubit(q)
         self._log(f"S({q})")
         self._ops.append(("s", [q], []))
         return self._apply_unitary(_S, [q])
 
-    def sdg(self, q: int) -> "HDQS":
+    def sdg(self, q: Optional[int] = None) -> "HDQS":
+        q = self._resolve_optional_qubit(q)
         self._log(f"Sdg({q})")
         self._ops.append(("sdg", [q], []))
         return self._apply_unitary(GATES["SDG"], [q])
 
-    def t(self, q: int) -> "HDQS":
+    def t(self, q: Optional[int] = None) -> "HDQS":
+        q = self._resolve_optional_qubit(q)
         self._log(f"T({q})")
         self._ops.append(("t", [q], []))
         return self._apply_unitary(_T, [q])
 
-    def tdg(self, q: int) -> "HDQS":
+    def tdg(self, q: Optional[int] = None) -> "HDQS":
+        q = self._resolve_optional_qubit(q)
         self._log(f"Tdg({q})")
         self._ops.append(("tdg", [q], []))
         return self._apply_unitary(GATES["TDG"], [q])
@@ -1130,6 +1071,46 @@ class HDQS:
             q, generalized_amplitude_damping_channel(p, gamma),
             "generalized_amplitude_damping")
 
+    _NOISE_CHANNEL_METHODS = frozenset({
+        "bit_flip", "phase_flip", "depolarizing",
+        "amplitude_damping", "phase_damping",
+    })
+
+    def with_noise(self, channel: str, *params) -> "HDQS":
+        """Return a NEW HDQS instance (this one is left untouched) that
+        replays every gate applied so far, inserting `channel` on every
+        qubit each gate touches, right after that gate. One-liner analog
+        of Cirq's `circuit.with_noise(cirq.depolarize(0.01))`; scoped to
+        the single-qubit channels already on this class (`channel` is one
+        of "bit_flip"/"phase_flip"/"depolarizing"/"amplitude_damping"/
+        "phase_damping", `*params` are that channel's own arguments, e.g.
+        `with_noise("depolarizing", 0.01)`).
+
+        Because HDQS executes eagerly rather than building a circuit
+        object first, "insert noise after the fact" means replaying the
+        recorded gate history (self._ops) onto a fresh density-matrix
+        instance rather than mutating a DAG in place -- the result is the
+        same circuit, but noise-affected, and this instance's own state
+        is unchanged. For gates that don't record every touched qubit
+        symmetrically (e.g. mcx's controls), noise is applied to every
+        qubit index the gate's own _ops entry lists, matching the common
+        "apply a gate-error channel per qubit the gate acts on"
+        convention used by most noisy-simulation tooling.
+        """
+        if channel not in self._NOISE_CHANNEL_METHODS:
+            raise ValueError(
+                f"with_noise: unknown channel {channel!r}; must be one "
+                f"of {sorted(self._NOISE_CHANNEL_METHODS)}")
+        noisy = HDQS(self.num_qubits, use_density_matrix=True)
+        channel_method = getattr(noisy, channel)
+        for name, qubits, gate_params in self._ops:
+            if name in ("measure", "reset", "barrier"):
+                continue  # non-unitary/no-op entries, nothing to replay
+            _qasm3_dispatch_gate(noisy, name, qubits, gate_params)
+            for q in qubits:
+                channel_method(q, *params)
+        return noisy
+
     def thermal_noise(self, q: int, p: float, T: float = 1.0) -> "HDQS":
         self._log(f"Thermal({q},p={p:.3g},T={T:.3g})")
         return self._apply_noise(q, thermal_noise_channel(p, T), "thermal")
@@ -1334,21 +1315,42 @@ class HDQS:
 
     # -- analysis -------------------------------------------------------------
 
-    def expectation(self, pauli_string: str) -> float:
-        """Expectation value of a Pauli string like 'ZZI' (qubit 0 leftmost).
+    def expectation(self, pauli_string: str,
+                    on: Optional[Sequence[int]] = None) -> float:
+        """Expectation value of a Pauli string.
+
+        Two forms:
+          q.expectation("ZZI")           # full string, one letter per qubit
+          q.expectation("Z", on=1)       # short form: Pauli letters at the
+          q.expectation("ZZ", on=[0,2])  # given qubit(s), identity elsewhere
+        `on` accepts a single int or a sequence the same length as
+        `pauli_string`; every other qubit is treated as I. The short form
+        exists so a Pauli acting on a handful of qubits out of a large
+        register doesn't require hand-writing an identity-padded string
+        the length of the whole register.
 
         Computed by axis-contraction in both modes and both backends —
         v0.3.0 built a dense 2^n x 2^n operator (and raised
         NotImplementedError on the GPU pure-state path)."""
-        s = pauli_string.upper()
-        if len(s) != self.num_qubits:
+        n = self.num_qubits
+        if on is not None:
+            on = [on] if isinstance(on, int) else list(on)
+            if len(on) != len(pauli_string):
+                raise ValueError(
+                    f"pauli_string has {len(pauli_string)} letter(s) but "
+                    f"on= gives {len(on)} qubit(s) -- these must match")
+            letters = dict(zip(on, pauli_string.upper()))
+            s = "".join(letters.get(q, "I") for q in range(n))
+        else:
+            s = pauli_string.upper()
+        if len(s) != n:
             raise ValueError(
-                f"pauli string must have length {self.num_qubits}")
+                f"pauli string must have length {n} qubits "
+                "(or pass on= to place a short string on specific qubits)")
         for ch in s:
             if ch not in "IXYZ":
                 raise ValueError(f"invalid Pauli letter: {ch}")
         xp = self._xp
-        n = self.num_qubits
         if not self._use_density_matrix:
             T = self._sv.reshape((2,) * n)
             for q, ch in enumerate(s):
@@ -2092,6 +2094,8 @@ def _qasm3_dispatch_gate(q: "HDQS", name: str, idx: List[int],
         q.ccx(idx[0], idx[1], idx[2])
     elif name == "cswap":
         q.cswap(idx[0], idx[1], idx[2])
+    elif name == "mcx":
+        q.mcx(idx[:-1], idx[-1])
     else:
         raise NotImplementedError(f"from_qasm3: gate {name!r}")
 

{sia_script-1.0.3 → sia_script-1.3.0/sia_script.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sia-script
-Version: 1.0.3
+Version: 1.3.0
 Summary: SIA — Simplified Integrated Architecture: SiaNTT, SIA-ELS (ABAP interpreter), the HDQS server client, and hdqs_engine (offline statevector quantum simulator — no server or API token required)
 Author-email: Sia Software Innovations Private Limited <info@siasoftwareinnovations.com>
 License: # PROPRIETARY SOFTWARE LICENSE

{sia_script-1.0.3 → sia_script-1.3.0}/sia_script.egg-info/SOURCES.txt

@@ -1,8 +1,6 @@
 LICENSE.md
-MANIFEST.in
 README.md
 pyproject.toml
-setup.py
 sia/__init__.py
 sia/els.py
 sia/hdqs.py
@@ -11,7 +9,5 @@ sia/ntt.py
 sia_script.egg-info/PKG-INFO
 sia_script.egg-info/SOURCES.txt
 sia_script.egg-info/dependency_links.txt
-sia_script.egg-info/not-zip-safe
 sia_script.egg-info/requires.txt
-sia_script.egg-info/top_level.txt
-src/hdqs_core.cpp
+sia_script.egg-info/top_level.txt

sia_script-1.0.3/MANIFEST.in

@@ -1,3 +0,0 @@
-include src/*.cpp
-include README.md LICENSE.md pyproject.toml setup.py
-recursive-include sia *.py

sia_script-1.0.3/setup.py

@@ -1,60 +0,0 @@
-"""
-Build script for the sia-script native extension (hdqs_core).
-
-This compiles src/hdqs_core.cpp into sia/hdqs_core.<platform-tag>.so via
-pybind11 -- the same mechanism Qiskit Aer and PennyLane's lightning.qubit
-use (a thin Python package wrapping a compiled kernel).
-
-Local development build:
-    pip install pybind11
-    python setup.py build_ext --inplace
-
-This places the compiled module directly in sia/, where hdqs_engine.py's
-`from . import hdqs_core` picks it up automatically. If the build fails or
-is skipped, hdqs_engine.py still works -- it falls back to the pure NumPy
-path and sets _NATIVE_AVAILABLE = False.
-"""
-import sys
-from setuptools import setup, Extension
-from pybind11.setup_helpers import Pybind11Extension, build_ext
-
-# -O3 for standard optimization. -march=native/-mavx2/-mavx512f are
-# deliberately NOT used here, and no longer need to be: hdqs_core.cpp
-# now does its own runtime CPU dispatch (GCC/Clang function
-# multiversioning + __builtin_cpu_supports, checked once at first call)
-# for the four hottest kernels. This one build, compiled with these
-# plain flags, contains scalar/AVX2/AVX-512 code paths simultaneously
-# and picks the fastest one the *running* CPU actually supports --
-# verified: compiled with zero SIMD flags, still dispatches to AVX-512
-# on an AVX-512-capable machine, at the same speed as an explicitly
-# -mavx512f-flagged build. No crash risk on older CPUs, no separate
-# "fast" build needed. (This applies to GCC/Clang on x86_64 --  MSVC/
-# Windows builds don't yet get automatic dispatch and fall back to the
-# single compile-time path, i.e. scalar unless /arch:AVX2 is passed
-# explicitly -- a known, stated gap, not a regression from before.)
-extra_compile_args = ["-O3", "-std=c++17"]
-extra_link_args = []
-
-if sys.platform == "win32":
-    extra_compile_args = ["/O2", "/std:c++17", "/openmp"]
-else:
-    extra_compile_args += ["-fopenmp"]
-    extra_link_args += ["-fopenmp"]
-
-ext_modules = [
-    Pybind11Extension(
-        "sia.hdqs_core",
-        ["src/hdqs_core.cpp"],
-        cxx_std=17,
-        extra_compile_args=extra_compile_args,
-        extra_link_args=extra_link_args,
-    ),
-]
-
-setup(
-    packages=["sia"],
-    package_dir={"sia": "sia"},
-    ext_modules=ext_modules,
-    cmdclass={"build_ext": build_ext},
-    zip_safe=False,
-)

sia_script-1.0.3/sia_script.egg-info/not-zip-safe

@@ -1 +0,0 @@
-