quantum-loop 0.2.0__py3-none-any.whl → 0.2.2__py3-none-any.whl

ql/__init__.py

@@ -12,11 +12,11 @@ but it is a concept of the principle of operation of quantum calculations on a r
 from __future__ import annotations
 
 __all__ = (
-    "LoopMode",
     "QuantumLoop",
+    "LoopMode",
     "count_qubits",
 )
 
 
-from ql.loop import LoopMode, QuantumLoop
-from ql.utils import count_qubits
+from ql.loop import QuantumLoop
+from ql.utils import LoopMode, count_qubits

ql/loop.py

@@ -10,8 +10,6 @@ but it is a concept of the principle of operation of quantum calculations on a r
 
 The module contains the following tools:
 
-- `LoopMode` - Quantum loop mode.
-- `count_qubits()` - Counting the number of conceptual qubits of your computer.
 - `QuantumLoop` - Separation of the cycle into quantum algorithms for multiprocessing data processing.
 """
 
@@ -19,15 +17,9 @@ from __future__ import annotations
 
 import concurrent.futures
 from collections.abc import Callable, Iterable
-from enum import Enum
 from typing import Any, Never, assert_never
 
-
-class LoopMode(Enum):
-    """Quantum loop mode."""
-
-    PROCESS_POOL = 1
-    THREAD_POOL = 2
+from ql.utils import LoopMode
 
 
 class QuantumLoop:
@@ -47,11 +39,8 @@ class QuantumLoop:
         max_workers: The maximum number of processes that can be used to
                      execute the given calls. If None or not given then as many
                      worker processes will be created as the machine has processors.
-        timeout: The maximum number of seconds to wait. If None, then there
-                 is no limit on the wait time.
-        chunksize: The size of the chunks the iterable will be broken into
-                   before being passed to a child process. This argument is only
-                   used by ProcessPoolExecutor; it is ignored by ThreadPoolExecutor.
+        timeout: The number of seconds to wait for the result if the future isn't done.
+                 If None, then there is no limit on the wait time.
         mode: The operating mode for a quantum loop: LoopMode.PROCESS_POOL | LoopMode.THREAD_POOL.
     """
 
@@ -61,43 +50,43 @@ class QuantumLoop:
         data: Iterable[Any],
         max_workers: int | None = None,
         timeout: float | None = None,
-        chunksize: int = 1,
         mode: LoopMode = LoopMode.PROCESS_POOL,
     ) -> None:
-        self.quantum = task
+        self.task = task
         self.data = data
         self.max_workers = max_workers
         self.timeout = timeout
-        self.chunksize = chunksize
         self.mode = mode
 
     def process_pool(self) -> list[Any]:
         """Better suitable for operations for which large processor resources are required."""
+        task = self.task
+        data = self.data
+        timeout = self.timeout
+        results: list[Any] = []
         with concurrent.futures.ProcessPoolExecutor(self.max_workers) as executor:
-            results = list(
-                executor.map(
-                    self.quantum,
-                    self.data,
-                    timeout=self.timeout,
-                    chunksize=self.chunksize,
-                ),
-            )
-        return results  # noqa: RET504
+            for item in data:
+                future = executor.submit(task, item)
+                result = future.result(timeout)
+                if result is not None:
+                    results.append(result)
+        return results
 
     def thread_pool(self) -> list[Any]:
         """More suitable for tasks related to input-output
         (for example, network queries, file operations),
         where GIL is freed during input-output operations."""  # noqa: D205, D209
+        task = self.task
+        data = self.data
+        timeout = self.timeout
+        results: list[Any] = []
         with concurrent.futures.ThreadPoolExecutor(self.max_workers) as executor:
-            results = list(
-                executor.map(
-                    self.quantum,
-                    self.data,
-                    timeout=self.timeout,
-                    chunksize=self.chunksize,
-                ),
-            )
-        return results  # noqa: RET504
+            for item in data:
+                future = executor.submit(task, item)
+                result = future.result(timeout)
+                if result is not None:
+                    results.append(result)
+        return results
 
     def run(self) -> list[Any]:
         """Run the quantum loop."""

ql/utils.py

@@ -1,8 +1,22 @@
-"""Utils."""
+"""Utils.
+
+The module contains the following tools:
+
+- `LoopMode` - Quantum loop mode.
+- `count_qubits()` - Counting the number of conceptual qubits of your computer.
+"""
 
 from __future__ import annotations
 
 import multiprocessing
+from enum import Enum
+
+
+class LoopMode(Enum):
+    """Quantum loop mode."""
+
+    PROCESS_POOL = 1
+    THREAD_POOL = 2
 
 
 def count_qubits() -> int:

{quantum_loop-0.2.0.dist-info → quantum_loop-0.2.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: quantum-loop
-Version: 0.2.0
+Version: 0.2.2
 Summary: A set of tools for quantum calculations.
 Project-URL: Homepage, https://github.com/kebasyaty/quantum-loop
 Project-URL: Repository, https://github.com/kebasyaty/quantum-loop
@@ -94,22 +94,28 @@ uv add quantum-loop
 ## Usage
 
 ```python
-from ql import LoopMode, QuantumLoop, count_qubits
+from ql import QuantumLoop, count_qubits
 
-# Counting the number of conceptual qubits of your computer.
-num = count_qubits()
-print(num)  # => 16
 
-def task(item):
+def task(num: int) -> int | None:
     """Quantum."""
-    return item * item
+    return num * num if num % 2 == 0 else None
 
-data = range(10)
 
-# Separation of the cycle into quantum algorithms for
-# multiprocessing data processing.
-results = QuantumLoop(task, data).run()
-print(results)  # => [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
+def main() -> None:
+    # Counting the number of conceptual qubits of your computer.
+    num = count_qubits()
+    print(num)  # => 16
+
+    # Separation of the cycle into quantum algorithms for
+    # multiprocessing data processing.
+    data = range(1, 10)
+    results = QuantumLoop(task, data).run()
+    print(results)  # => [4, 16, 36, 64]
+
+
+if __name__ == "__main__":
+    main()
 ```
 
 ## Changelog

quantum_loop-0.2.2.dist-info/RECORD

@@ -0,0 +1,8 @@
+ql/__init__.py,sha256=NLJqDzx9z_phVVusAGUxDyKJhW35_1Ex0PoiZbvStsQ,607
+ql/loop.py,sha256=4gU1lv_YbDfB3Ed03gzmFIhwOKlOwCCsw0zCfTUE4bI,3778
+ql/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+ql/utils.py,sha256=7q9hj1Z3Yqmo2t4EpXDu5aQ8AaRpS984TsjHbiNaeCA,868
+quantum_loop-0.2.2.dist-info/METADATA,sha256=VjBC02si27KKEXmuTpLTzfXppY2j6lMWcFBGP0Cx44o,5990
+quantum_loop-0.2.2.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+quantum_loop-0.2.2.dist-info/licenses/LICENSE,sha256=2zZINd6m_jNYlowdQImlEizyhSui5cBAJZRhWQURcEc,1095
+quantum_loop-0.2.2.dist-info/RECORD,,

quantum_loop-0.2.0.dist-info/RECORD

@@ -1,8 +0,0 @@
-ql/__init__.py,sha256=ZRQ0z14P0H_TEUnAspjNJuWxDul-S03U8iVa5Tg8SQc,607
-ql/loop.py,sha256=Lcx_b_FQHOnf7HDJKAll8rzU_6f8EU4V5ozaLPj5kMI,4132
-ql/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-ql/utils.py,sha256=MPRUYSlD8DN7Hb28X3ru9bBnsiQ39IPAQ0w23sikRZM,579
-quantum_loop-0.2.0.dist-info/METADATA,sha256=rLcA5Xzn4paiSAmOn2cCjwaQDotIElojhYdqFUAU6mM,5883
-quantum_loop-0.2.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-quantum_loop-0.2.0.dist-info/licenses/LICENSE,sha256=2zZINd6m_jNYlowdQImlEizyhSui5cBAJZRhWQURcEc,1095
-quantum_loop-0.2.0.dist-info/RECORD,,