xloft 0.4.3__py3-none-any.whl → 0.4.5__py3-none-any.whl

xloft/__init__.py

@@ -5,7 +5,6 @@ Modules exported by this package:
 - `namedtuple`: Class imitates the behavior of the _named tuple_.
 - `human` - A collection of instruments for converting data to format is convenient for humans.
 - `quantum` - A set of tools for quantum calculations.
-              Hint: uv add xloft[quantum]
 """
 
 from __future__ import annotations

xloft/quantum.py

@@ -0,0 +1,132 @@
+"""A set of tools for quantum calculations.
+
+A Qubit in a regular computer is quantum of algorithm that is executed in
+one iteration of a cycle in a separate processor thread.
+
+Quantum is a function with an algorithm of task for data processing.
+
+In this case, the Qubit is not a single information,
+but it is a concept of the principle of operation of quantum calculations on a regular computer.
+
+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.
+"""
+
+from __future__ import annotations
+
+import concurrent.futures
+import multiprocessing
+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
+
+
+def count_qubits() -> int:
+    """Counting the number of conceptual qubits of your computer.
+
+    Conceptual qubit is quantum of algorithm (task) that is executed in
+    iterations of a cycle in a separate processor thread.
+
+    Quantum of algorithm is a function for data processing.
+
+    Examples:
+        >>> from xloft.quantum import count_qubits
+        >>> count_qubits()
+        16
+
+    Returns:
+        The number of conceptual qubits.
+    """
+    return multiprocessing.cpu_count()
+
+
+class QuantumLoop:
+    """Separation of the cycle into quantum algorithms for multiprocessing data processing.
+
+    Examples:
+        >>> from xloft.quantum import QuantumLoop
+        >>> def task(item):
+        ... return item * item
+        >>> data = range(10)
+        >>> QuantumLoop(task, data).run()
+        [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
+
+    Args:
+        task: Function with a task algorithm.
+        data: The data that needs to be processed.
+        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.
+        mode: The operating mode for a quantum loop: LoopMode.PROCESS_POOL | LoopMode.THREAD_POOL.
+    """
+
+    def __init__(  # noqa: D107
+        self,
+        task: Callable,
+        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.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."""
+        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
+
+    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
+        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
+
+    def run(self) -> list[Any]:
+        """Run the quantum loop."""
+        results: list[Any] = []
+        match self.mode.value:
+            case 1:
+                results = self.process_pool()
+            case 2:
+                results = self.thread_pool()
+            case _ as unreachable:
+                assert_never(Never(unreachable))
+        return results

{xloft-0.4.3.dist-info → xloft-0.4.5.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: xloft
-Version: 0.4.3
+Version: 0.4.5
 Summary: (XLOFT) X-Library of tools
 Project-URL: Homepage, https://github.com/kebasyaty/xloft
 Project-URL: Repository, https://github.com/kebasyaty/xloft
@@ -25,9 +25,6 @@ Classifier: Programming Language :: Python :: Implementation :: CPython
 Classifier: Topic :: Utilities
 Classifier: Typing :: Typed
 Requires-Python: <4.0,>=3.12
-Requires-Dist: quantum
-Provides-Extra: quantum
-Requires-Dist: quantum; extra == 'quantum'
 Description-Content-Type: text/markdown
 
 <div align="center">
@@ -83,8 +80,6 @@ Online browsable documentation is available at [https://kebasyaty.github.io/xlof
 
 ```shell
 uv add xloft
-# For a Quantum module:
-uv add xloft[quantum]
 ```
 
 ## Usage
@@ -178,7 +173,7 @@ print(s)  # => 1023.999 KB
 - **Quantum**
 
 ```python
-from quantum import LoopMode, QuantumLoop, count_qubits
+from xloft.quantum import LoopMode, QuantumLoop, count_qubits
 
 # Counting the number of conceptual qubits of your computer.
 num = count_qubits()
@@ -191,8 +186,7 @@ def task(item):
 data = range(10)
 
 # Separation of the cycle into quantum algorithms for multiprocessing data processing.
-qloop = QuantumLoop(task, data)
-results = qloop.run()
+results = QuantumLoop(task, data).run()
 print(results)  # => [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
 ```
 

xloft-0.4.5.dist-info/RECORD

@@ -0,0 +1,10 @@
+xloft/__init__.py,sha256=UL4IR8EcFjgWoQFayl6FrK2u8QmZytGCwa_E1jDiCmE,475
+xloft/errors.py,sha256=hZcmF0QVVdvE5oM1jsXymRk_pPGgDSnUDM9wx9zJAYQ,895
+xloft/human.py,sha256=odRbUF_58YuFWC_VQeRDZ-6ifHDiiAH2HNb5G5K6JIM,1106
+xloft/namedtuple.py,sha256=a_l3bZF-L2I7MGxuF2CXzAHgNai-Vyj6SY1ODwxs7TU,6856
+xloft/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+xloft/quantum.py,sha256=ZkFqqFROC9j5JbwJmej3yL9VJcqElPrrimFTz0Pe3Mk,4679
+xloft-0.4.5.dist-info/METADATA,sha256=0cAqqMXQdh5I_DMw9Rm5UU6agFU13OlYlyOpNpYZIgc,7241
+xloft-0.4.5.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+xloft-0.4.5.dist-info/licenses/LICENSE,sha256=2zZINd6m_jNYlowdQImlEizyhSui5cBAJZRhWQURcEc,1095
+xloft-0.4.5.dist-info/RECORD,,

xloft-0.4.3.dist-info/RECORD

@@ -1,9 +0,0 @@
-xloft/__init__.py,sha256=1bdoDR6AzzL_Rhpp3LLbt6swYlZoZjmfnpJ4sGRr3Ug,518
-xloft/errors.py,sha256=hZcmF0QVVdvE5oM1jsXymRk_pPGgDSnUDM9wx9zJAYQ,895
-xloft/human.py,sha256=odRbUF_58YuFWC_VQeRDZ-6ifHDiiAH2HNb5G5K6JIM,1106
-xloft/namedtuple.py,sha256=a_l3bZF-L2I7MGxuF2CXzAHgNai-Vyj6SY1ODwxs7TU,6856
-xloft/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-xloft-0.4.3.dist-info/METADATA,sha256=Wwp_dseakyHPsBDi6lFaSvLd36lJ9phIFrMO-dZS_HI,7385
-xloft-0.4.3.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-xloft-0.4.3.dist-info/licenses/LICENSE,sha256=2zZINd6m_jNYlowdQImlEizyhSui5cBAJZRhWQURcEc,1095
-xloft-0.4.3.dist-info/RECORD,,