luna-quantum 0.0.16__py3-none-any.whl

luna_sdk/schemas/use_cases/traffic_flow.py

@@ -0,0 +1,34 @@
+from typing import List, Literal
+
+from luna_sdk.schemas.use_cases.base import UseCase
+
+
+class TrafficFlow(UseCase):
+    """
+    # Traffic Flow Optimization
+
+    Description
+    -----------
+
+    The Traffic Flow Optimization problem tries to minimize the total time for a given
+    set of cars to travel between their individual sources and destinations. This is
+    achieved by minimizing the number of overlapping segments between assigned routes
+    for each car.
+
+    Links
+    -----
+
+    [Description and Transformation](https://www.frontiersin.org/articles/10.3389/fict.2017.00029/full)
+
+    Attributes
+    ----------
+
+    ### car_routes: List[List[List[int]]]
+        \n The route segments of each possible route for each car.
+        \n (e.g. for two cars, where car 1 can take either route 0, 1, 2 or route 0, 3,
+        4 and car 2 can take either route 3, 0, 5 or route 6, 7, 5:
+        \n _[[[0, 1, 2], [0, 3, 4]], [[3, 0, 5], [6, 7, 5]]]_
+    """
+
+    name: Literal["TFO"] = "TFO"
+    car_routes: List[List[List[int]]]

luna_sdk/schemas/use_cases/travelling_salesman_problem.py

@@ -0,0 +1,52 @@
+from typing import Dict, Literal, Optional
+
+from pydantic import Field
+
+from luna_sdk.schemas.use_cases.base import UseCase
+
+
+class TravellingSalesmanProblem(UseCase):
+    """
+    # Travelling Salesman
+
+    Description
+    -----------
+
+    The Travelling Salesman problem, either for a directed or undirected graph, asks the
+    following: given a graph, where the edges are labeled with the distances between the
+    corresponding nodes, what is the shortest possible route that visits each node
+    exactly once and returns to the origin node?
+
+    Links
+    -----
+
+    [Wikipedia](https://en.wikipedia.org/wiki/Travelling_salesman_problem)
+
+    [Transformation](https://arxiv.org/pdf/1302.5843.pdf)
+
+    Attributes
+    ----------
+
+    ### graph: Dict[int, Dict[int, Dict[str, float]]]
+        \n Problem graph for the travelling salesman problem in form of nested
+        dictionaries.
+        \n (e.g. fully connected graph with 3 nodes:
+        \n _{0: {1: {}, 2: {}}, 1: {0: {}, 2: {}}, 2: {0: {}, 1: {}}}_
+        \n or _networkx.to_dict_of_dicts(networkx.complete_graph(3))_ )
+
+    ### A: Optional[float]
+        \n Positive penalty value which enforces that each node is visited exactly once.
+        \n if _None_, will be calculated with the equation: _A = B * _max_weight_ + 1_
+        \n Default: _None_
+
+    ### B: Optional[float]
+        \n Positive penalty value (_B * _max_weight_) < A_) which helps find the
+        shortest route.
+        \n Default: _1.0_
+    """
+
+    name: Literal["TSP"] = "TSP"
+    graph: Dict[str, Dict[str, Dict[str, float]]] = Field(name="graph")  # type: ignore
+    directed: Optional[bool] = False
+    B: Optional[float] = 1.0
+    A: Optional[float] = None

luna_sdk/schemas/use_cases/type_aliases.py

@@ -0,0 +1,11 @@
+from typing import Dict, Tuple, Union
+
+Node = Union[int, str]
+
+NestedDictGraph = Dict[Node, Dict[Node, Dict[str, float]]]
+
+NestedDictIntGraph = Dict[int, Dict[int, Dict[str, float]]]
+
+CalculusLiteral = Tuple[int, bool]
+
+Clause = Tuple[CalculusLiteral, ...]

luna_sdk/schemas/use_cases/weighted_max_cut.py

@@ -0,0 +1,36 @@
+from typing import Dict, Literal
+
+from luna_sdk.schemas.use_cases.base import UseCase
+
+
+class WeightedMaxCut(UseCase):
+    """
+    # Weighted Maximum Cut
+
+    Description
+    -----------
+
+    The Weighted Maximum Cut problem tries to find a cut that maximizes the weight of
+    intersecting edges in an undirected weighted graph.
+
+    Links
+    -----
+
+    [Wikipedia](https://en.wikipedia.org/wiki/Maximum_cut)
+
+    [Transformation](https://arxiv.org/pdf/2009.05008.pdf)
+
+    Attributes
+    ----------
+
+    ### graph: Dict[int, Dict[int, Dict[str, float]]]
+        \n Problem graph for the weighted maximum cut problem in form of nested
+        dictionaries.
+        \n Every edge has to have an assigned weight.
+        \n (e.g. fully connected graph with 3 nodes and edge weights:
+        \n _{0: {1: {"weight": 1}, 2: {"weight": 1}}, 1: {0: {"weight": 1},
+        2: {"weight": 1}}, 2: {0: {"weight": 1}, 1: {"weight": 1}}}_ )
+    """
+
+    name: Literal["WMC"] = "WMC"
+    graph: Dict[int, Dict[int, Dict[str, float]]]

luna_sdk/utils/qpu_tokens.py

@@ -0,0 +1,52 @@
+import os
+
+from luna_sdk.schemas import QpuToken, QpuTokenSource
+from luna_sdk.schemas.rest.qpu_token.token_provider import (
+    RestAPITokenProvider,
+    AWSQpuTokens,
+)
+
+
+def extract_qpu_tokens_from_env() -> RestAPITokenProvider:
+    ibm_token = os.environ.get("LUNA_IBM_TOKEN")
+    dwave_token = os.environ.get("LUNA_DWAVE_TOKEN")
+    qctrl_token = os.environ.get("LUNA_QCTRL_TOKEN")
+    fujitsu_token = os.environ.get("LUNA_FUJITSU_TOKEN")
+    aws_access_key = os.environ.get("LUNA_AWS_ACCESS_KEY")
+    aws_access_secret_key = os.environ.get("LUNA_AWS_SECRET_ACCESS_KEY")
+    return RestAPITokenProvider(
+        ibm=QpuToken(
+            source=QpuTokenSource.INLINE,
+            token=ibm_token,
+        )
+        if ibm_token
+        else None,
+        dwave=QpuToken(
+            source=QpuTokenSource.INLINE,
+            token=dwave_token,
+        )
+        if dwave_token
+        else None,
+        qctrl=QpuToken(
+            source=QpuTokenSource.INLINE,
+            token=qctrl_token,
+        )
+        if qctrl_token
+        else None,
+        fujitsu=QpuToken(
+            source=QpuTokenSource.INLINE,
+            token=fujitsu_token,
+        )
+        if fujitsu_token
+        else None,
+        aws=AWSQpuTokens(
+            aws_access_key=QpuToken(
+                source=QpuTokenSource.INLINE,
+                token=aws_access_key,
+            ),
+            aws_secret_access_key=QpuToken(
+                source=QpuTokenSource.INLINE,
+                token=aws_access_secret_key,
+            ),
+        ),
+    )