jijmodeling 2.0.0a6__cp38-abi3-manylinux_2_28_aarch64.whl → 2.0.0a8__cp38-abi3-manylinux_2_28_aarch64.whl

jijmodeling/__init__.pyi

@@ -24,32 +24,39 @@ class Compiler:
     def from_problem(problem:Problem, instance_data:typing.Mapping[builtins.str, builtins.int | builtins.float | numpy.typing.NDArray[numpy.float64] | numpy.typing.NDArray[numpy.int64] | list]) -> Compiler: ...
 
 class Constraint:
-    name: builtins.str
-    sense: ConstraintSense
-    left: Expression
-    right: Expression
-    expression: Expression
-    is_equality: builtins.bool
-    r"""
-    Returns true if the constraint is an equality constraint.
-    
-    Returns
-    --------
-    `bool`: True if the constraint is an equality constraint. Otherwise, False.
-    
-    Examples
-    ---------
-    
-    ```python
-    >>> import jijmodeling as jm
-    >>> N = jm.Placeholder("N")
-    >>> i = jm.Element("i", belong_to=N)
-    >>> x = jm.BinaryVar("x", shape=(N,))
-    >>> constraint = jm.Constraint("constraint", jm.sum(i, x[i]) == 1)
-    >>> assert constraint.is_equality()
-    
-    ```
-    """
+    @property
+    def name(self) -> builtins.str: ...
+    @property
+    def sense(self) -> ConstraintSense: ...
+    @property
+    def left(self) -> Expression: ...
+    @property
+    def right(self) -> Expression: ...
+    @property
+    def expression(self) -> Expression: ...
+    @property
+    def is_equality(self) -> builtins.bool:
+        r"""
+        Returns true if the constraint is an equality constraint.
+        
+        Returns
+        --------
+        `bool`: True if the constraint is an equality constraint. Otherwise, False.
+        
+        Examples
+        ---------
+        
+        ```python
+        >>> import jijmodeling as jm
+        >>> N = jm.Placeholder("N")
+        >>> i = jm.Element("i", belong_to=N)
+        >>> x = jm.BinaryVar("x", shape=(N,))
+        >>> constraint = jm.Constraint("constraint", jm.sum(i, x[i]) == 1)
+        >>> assert constraint.is_equality()
+        
+        ```
+        """
+    @property
     def is_inequality(self) -> builtins.bool:
         r"""
         Returns true if the constraint is an inequality constraint.
@@ -149,13 +156,20 @@ class DecisionVar:
     
     ```
     """
-    name: builtins.str
-    kind: DecisionVarKind
-    description: builtins.str
-    ndim: builtins.int
-    shape: tuple
-    lower_bound: Expression | builtins.list[Expression]
-    upper_bound: Expression | builtins.list[Expression]
+    @property
+    def name(self) -> builtins.str: ...
+    @property
+    def kind(self) -> DecisionVarKind: ...
+    @property
+    def description(self) -> builtins.str: ...
+    @property
+    def ndim(self) -> builtins.int: ...
+    @property
+    def shape(self) -> tuple: ...
+    @property
+    def lower_bound(self) -> Expression | builtins.list[Expression]: ...
+    @property
+    def upper_bound(self) -> Expression | builtins.list[Expression]: ...
     def __repr__(self) -> builtins.str: ...
     def __pow__(self, exponent:typing.Any, modulo:typing.Optional[typing.Any]=None) -> Expression: ...
     def __rpow__(self, base:typing.Any, modulo:typing.Optional[typing.Any]=None) -> Expression: ...
@@ -211,8 +225,182 @@ class DecoratedProblem(typing.Protocol):
     r"""
     A variant of `Problem` that is only available in Decorator API provided by `Problem.compile`.
     """
+    @typing.overload
+    def Constraint(self, name:builtins.str, expressions:typing.Generator[Expression], description:typing.Optional[builtins.str]=None) -> Constraint:
+        r"""
+        Constructs `Constraint` object with comprehension syntax, __WITHOUT__ registering it to the problem.
+        Use `+=` operator to register the constraint to the problem.
+        """
+    @typing.overload
+    def Constraint(self, name:builtins.str, expression:Expression | builtins.int | builtins.float | DecisionVar | Placeholder | list | tuple | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any], domain:typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any], description:typing.Optional[builtins.str]=None) -> Constraint:
+        r"""
+        Constructs `Constraint` object from index set and function to build comparison expression from each index, __WITHOUT__ registering it to the problem.
+        Use `+=` operator to register the constraint to the problem.
+        """
+    @typing.overload
+    def Constraint(self, name:builtins.str, expression:Expression | builtins.int | builtins.float | DecisionVar | Placeholder | list | tuple | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any], description:typing.Optional[builtins.str]=None) -> Constraint:
+        r"""
+        Constructs `Constraint` object from comparison expression, __WITHOUT__ registering it to the problem.
+        Use `+=` operator to register the constraint to the problem.
+        """
     def __iadd__(self, other:typing.Any) -> DecoratedProblem: ...
-    def Placeholder(self, name:typing.Optional[builtins.str]=None, *, ndim:typing.Optional[builtins.int]=None, shape:typing.Optional[typing.Sequence[Expression | builtins.int | builtins.float | DecisionVar | Placeholder | list | tuple | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any]]]=None, dtype:DataType | type=DataType.FLOAT, jagged:builtins.bool=False, latex:typing.Optional[builtins.str]=None, description:typing.Optional[builtins.str]=None) -> Placeholder: ...
+    def used_placeholders(self) -> builtins.list[Placeholder]: ...
+    def get_problem_schema(self) -> dict:
+        r"""
+        Returns the schema of the problem.
+        
+        Returns
+        --------
+        - `schema`: The dictionary containing the schema of the problem.
+        """
+    def generate_random_dataset(self, _default:typing.Any, _options:typing.Any, _seed:typing.Optional[builtins.int]) -> typing.Any:
+        r"""
+        Generates a dictionary of random `InstanceDataValue` for a given problem.
+        To generate `ommx.v1.Instance` object directly, use `InstanceDataValue.generate_random_instance` instead.
+        
+        Args
+        -----
+        - `options` (optional): a dictionary of range parameters for each separate placeholders. The key must be the name of the placeholder and the value must be range parameter (as described in "Range Parameters and Range Syntax" below).
+        - `default` (optional): default range parameters for placeholders which is not specified in `options`.
+        - `seed` (optional): seed for random number generation.
+        
+        Returns
+        --------
+        `dict`: The dictionary from the name of placeholders to the generated `InstanceDataValue` objects. To be fed to `Interpreter.eval_problem`.
+        
+        Range Parameters and Range Syntax
+        ----------------------------------
+        A range parameter is a dictionary consisting of the following fields:
+        - `size` (optional): interval of natural numbers for the size of each array dimension (default: `range(1, 6)`)
+        - `value` (optional): interval of real numbers for the value of each array element (default: `range(-1.0, 1.0)` - a uniform distribution on a closed interval $[-1.0, 1.0]$).
+        
+        Example range parameter config:
+        
+        ```python
+        {"size": range(2, 10), "value": jm.range.value.closed(100.0, 200.0)}
+        ```
+        
+        Intervals are expressed as a range object.
+        Currently, the following syntax is supported for range objects:
+        
+        1. Direct value of type `int` or `float` - it corresponds to a singleton interval $[a, a] = \{a\}$. In random generation context, this just means a constant fixed value.
+        2. Use the functions from `jijmodeling.range`, `jijmodeling.range.size`, or `jijmodeling.range.value` modules.
+           - Use functions from `jij.modeling.range.size` to specify (non-negative) integer intervals, and `jij.modeling.range.value` for real intervals. `jij.modeling.range` dynamically determines the type of the range based on the input.
+           - These three modules provides the following combinators (see the module documents for more details.):
+                    - `closed(a, b)`: a closed interval $[a, b]$
+                    - `open(a, b)`: an open interval $(a, b)$
+                    - `closed_open(a, b)`: an upper half-open interval $[a, b)$
+                    - `open_closed(a, b)`: a lower half-open interval $(a, b]$
+                    - `greater_than(a)`: an open interval $(a, \infty)$
+                    - `at_least(a)`: a closed interval $[a, \infty)$
+                    - `less_than(a)`: an open interval $(-\infty, a)$
+                    - `at_most(a)`: a closed interval $(-\infty, a]$
+        3. Use `range` builtin function: this is equivalent to `jijmodeling.range.value.closed_open(a, b)`.
+           - Any python range object with `step = 1` can be used as a size range; otherwise it results in runtime error.
+        4. Use a tuple: raw tuple `(a, b)` is equivalent to `jijmodeling.range.closed_open(a, b)` if `a` and `b` are either `int` or `float`.
+           - You can also use bound object as a tuple component; in such case, both tuple components must be one of the following:
+        
+                1. A string `"Unbounded"` means $-\infty$ (in the first component) or $\infty$ (the second).
+                2. A dictionary `{"Included": a}` means the endpoint is inclusive.
+                3. A dictionary `{"Excluded": a}` means the endpoint is exclusive.
+           - Examples:
+                    - `(1.2, 4)` is equivalent to `closed_open(1.2, 4)`,
+                    - `(-1, {"Included": 1})` is equivalent to `closed(-1, 1)`,
+                    - `(-5, {"Excluded": 4})` is equivalent to `closed_open(-5, 4)` and built in function `range(-5, 4)`,
+                    - `({"Excluded": 1}, {"Excluded": 2.5})` is equivalent to `open(1, 2.5)`,
+                    - `({"Included": -1}, "Unbounded")` is equivalent to `at_least(-1)`.
+                    - `(5, "Unbounded")` is **INVALID**; `5` must be bound object.
+        5. The range object: A dictionary of form `{"start": lb, "end": ub}`, where both `lb` and `ub` are the bound object described as above.
+        
+        Examples
+        ---------
+        ```python
+        >>> import jijmodeling as jm
+        >>> import builtins
+        >>> N = jm.Placeholder("N", dtype=jm.DataType.INTEGER)
+        >>> c = jm.Placeholder("c", dtype=jm.DataType.FLOAT, shape=(N,))
+        >>> x = jm.BinaryVar("x", shape=(N,))
+        >>> i = jm.Element("i", belong_to=N)
+        
+        >>> problem = jm.Problem("problem")
+        >>> problem += jm.sum(i, c[i] * x[i])
+        
+        >>> inputs = problem.generate_random_dataset(
+        ...     options={
+        ...         'N': {"value": builtins.range(10, 20)},
+        ...         'c': {"value": jm.range.value.closed(-1.0, 1.0)}
+        ...          # You can also specify "size" for the range of jagged array dimension size.
+        ...     },
+        ...     seed=123 # omittable
+        ... )
+        >>> assert set(inputs.keys()) == {"N", "c"}
+        >>> inputs
+        {'N': 11.0, 'c': array([ 0.93914459, -0.06511935, -0.7460324 , -0.32443706,  0.99981451,
+               -0.24407535,  0.31329469,  0.52206453, -0.1291936 ,  0.30443087,
+                0.53125838])}
+        
+        ```
+        """
+    def generate_random_instance(self, _default:typing.Any, _options:typing.Any, _seed:typing.Optional[builtins.int], _hints:typing.Optional[typing.Any]) -> typing.Any:
+        r"""
+        Generates random `ommx.v1.Instance` for a given problem.
+        See also `InstanceDataValue.generate_random_dataset`.
+        
+        Args
+        -----
+        - `options` (optional): a dictionary of range parameters for each separate placeholders. The key must be the name of the placeholder and the value must be range parameter (as described in "Range Parameters and Range Syntax" section in :func:`~jijmodeling.Problem.generate_random_dataset`).
+        - `default` (optional): default range parameters for placeholders which is not specified in `options`.
+        - `seed` (optional): seed for random number generation.
+        - `hints` (optional): the hints to be detected during compilation see `Interpreter.eval_problem` for more details.
+        
+        Returns
+        --------
+        `instance`: The OMMX v1 instance object.
+        
+        Examples
+        ---------
+        ```python
+        >>> import jijmodeling as jm
+        >>> import builtins
+        >>> import ommx.v1
+        >>> N = jm.Placeholder("N", dtype=jm.DataType.INTEGER)
+        >>> c = jm.Placeholder("c", dtype=jm.DataType.FLOAT, shape=(N,))
+        >>> x = jm.BinaryVar("x", shape=(N,))
+        >>> i = jm.Element("i", belong_to=N)
+        
+        >>> problem = jm.Problem("problem")
+        >>> problem += jm.sum(i, c[i] * x[i])
+        
+        >>> instance = problem.generate_random_instance(
+        ...     options={
+        ...         'N': {"value": builtins.range(10, 20)},
+        ...         'c': {"value": jm.range.value.closed(-1.0, 1.0)}
+        ...     },
+        ...     seed=123
+        ... )
+        >>> assert type(instance) is ommx.v1.Instance
+        
+        ```
+        """
+    def type_of(self, name:builtins.str) -> Type: ...
+    def infer(self, expr:Expression | builtins.int | builtins.float | DecisionVar | Placeholder | list | tuple | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any]) -> Type: ...
+    def decision_vars(self) -> builtins.dict[builtins.str, DecisionVar]:
+        r"""
+        Returns a dictionary of decision variables in the problem.
+        
+        Returns
+        --------
+        `dict[str, DecisionVar]`: Dictionary mapping variable names to DecisionVar objects.
+        """
+    def placeholders(self) -> builtins.dict[builtins.str, Placeholder]:
+        r"""
+        Returns a dictionary of placeholders in the problem.
+        
+        Returns
+        --------
+        `dict[str, Placeholder]`: Dictionary mapping placeholder names to Placeholder objects.
+        """
+    def Placeholder(self, name:typing.Optional[builtins.str]=None, *, ndim:typing.Optional[builtins.int]=None, shape:typing.Optional[typing.Sequence[Expression | builtins.int | builtins.float | DecisionVar | Placeholder | list | tuple | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any]]]=None, dtype:DataType | type | tuple=DataType.FLOAT, jagged:builtins.bool=False, latex:typing.Optional[builtins.str]=None, description:typing.Optional[builtins.str]=None) -> Placeholder: ...
     def Integer(self, name:typing.Optional[builtins.str]=None, *, ndim:typing.Optional[builtins.int]=None, shape:typing.Optional[typing.Sequence[Expression | builtins.int | builtins.float | DecisionVar | Placeholder | list | tuple | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any]]]=None, jagged:builtins.bool=False, latex:typing.Optional[builtins.str]=None, description:typing.Optional[builtins.str]=None) -> Placeholder:
         r"""
         A shorthand for `Problem.Placeholder(dtype=int)`
@@ -426,151 +614,6 @@ class DecoratedProblem(typing.Protocol):
         ```
         """
     def SemiContinuousVar(self, name:typing.Optional[builtins.str]=None, *, shape:typing.Optional[typing.Sequence[Expression | builtins.int | builtins.float | DecisionVar | Placeholder | list | tuple | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any]]]=None, lower_bound:Expression | builtins.int | builtins.float | DecisionVar | Placeholder | list | tuple | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any] | typing.Sequence[Expression | builtins.int | builtins.float | DecisionVar | Placeholder | list | tuple | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any]], upper_bound:Expression | builtins.int | builtins.float | DecisionVar | Placeholder | list | tuple | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any] | typing.Sequence[Expression | builtins.int | builtins.float | DecisionVar | Placeholder | list | tuple | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any]], latex:typing.Optional[builtins.str]=None, description:typing.Optional[builtins.str]=None) -> DecisionVar: ...
-    def Constraint(self, name:builtins.str, expression:Expression | builtins.int | builtins.float | DecisionVar | Placeholder | list | tuple | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any], *, description:typing.Optional[builtins.str]=None) -> Constraint:
-        r"""
-        Constructs `Constraint` object, __WITHOUT__ registering it to the problem.
-        Use `+=` operator to register the constraint to the problem.
-        """
-    def used_placeholders(self) -> builtins.list[Placeholder]: ...
-    def get_problem_schema(self) -> dict:
-        r"""
-        Returns the schema of the problem.
-        
-        Returns
-        --------
-        - `schema`: The dictionary containing the schema of the problem.
-        """
-    def generate_random_dataset(self, _default:typing.Any, _options:typing.Any, _seed:typing.Optional[builtins.int]) -> typing.Any:
-        r"""
-        Generates a dictionary of random `InstanceDataValue` for a given problem.
-        To generate `ommx.v1.Instance` object directly, use `InstanceDataValue.generate_random_instance` instead.
-        
-        Args
-        -----
-        - `options` (optional): a dictionary of range parameters for each separate placeholders. The key must be the name of the placeholder and the value must be range parameter (as described in "Range Parameters and Range Syntax" below).
-        - `default` (optional): default range parameters for placeholders which is not specified in `options`.
-        - `seed` (optional): seed for random number generation.
-        
-        Returns
-        --------
-        `dict`: The dictionary from the name of placeholders to the generated `InstanceDataValue` objects. To be fed to `Interpreter.eval_problem`.
-        
-        Range Parameters and Range Syntax
-        ----------------------------------
-        A range parameter is a dictionary consisting of the following fields:
-        - `size` (optional): interval of natural numbers for the size of each array dimension (default: `range(1, 6)`)
-        - `value` (optional): interval of real numbers for the value of each array element (default: `range(-1.0, 1.0)` - a uniform distribution on a closed interval $[-1.0, 1.0]$).
-        
-        Example range parameter config:
-        
-        ```python
-        {"size": range(2, 10), "value": jm.range.value.closed(100.0, 200.0)}
-        ```
-        
-        Intervals are expressed as a range object.
-        Currently, the following syntax is supported for range objects:
-        
-        1. Direct value of type `int` or `float` - it corresponds to a singleton interval $[a, a] = \{a\}$. In random generation context, this just means a constant fixed value.
-        2. Use the functions from `jijmodeling.range`, `jijmodeling.range.size`, or `jijmodeling.range.value` modules.
-           - Use functions from `jij.modeling.range.size` to specify (non-negative) integer intervals, and `jij.modeling.range.value` for real intervals. `jij.modeling.range` dynamically determines the type of the range based on the input.
-           - These three modules provides the following combinators (see the module documents for more details.):
-                    - `closed(a, b)`: a closed interval $[a, b]$
-                    - `open(a, b)`: an open interval $(a, b)$
-                    - `closed_open(a, b)`: an upper half-open interval $[a, b)$
-                    - `open_closed(a, b)`: a lower half-open interval $(a, b]$
-                    - `greater_than(a)`: an open interval $(a, \infty)$
-                    - `at_least(a)`: a closed interval $[a, \infty)$
-                    - `less_than(a)`: an open interval $(-\infty, a)$
-                    - `at_most(a)`: a closed interval $(-\infty, a]$
-        3. Use `range` builtin function: this is equivalent to `jijmodeling.range.value.closed_open(a, b)`.
-           - Any python range object with `step = 1` can be used as a size range; otherwise it results in runtime error.
-        4. Use a tuple: raw tuple `(a, b)` is equivalent to `jijmodeling.range.closed_open(a, b)` if `a` and `b` are either `int` or `float`.
-           - You can also use bound object as a tuple component; in such case, both tuple components must be one of the following:
-        
-                1. A string `"Unbounded"` means $-\infty$ (in the first component) or $\infty$ (the second).
-                2. A dictionary `{"Included": a}` means the endpoint is inclusive.
-                3. A dictionary `{"Excluded": a}` means the endpoint is exclusive.
-           - Examples:
-                    - `(1.2, 4)` is equivalent to `closed_open(1.2, 4)`,
-                    - `(-1, {"Included": 1})` is equivalent to `closed(-1, 1)`,
-                    - `(-5, {"Excluded": 4})` is equivalent to `closed_open(-5, 4)` and built in function `range(-5, 4)`,
-                    - `({"Excluded": 1}, {"Excluded": 2.5})` is equivalent to `open(1, 2.5)`,
-                    - `({"Included": -1}, "Unbounded")` is equivalent to `at_least(-1)`.
-                    - `(5, "Unbounded")` is **INVALID**; `5` must be bound object.
-        5. The range object: A dictionary of form `{"start": lb, "end": ub}`, where both `lb` and `ub` are the bound object described as above.
-        
-        Examples
-        ---------
-        ```python
-        >>> import jijmodeling as jm
-        >>> import builtins
-        >>> N = jm.Placeholder("N", dtype=jm.DataType.INTEGER)
-        >>> c = jm.Placeholder("c", dtype=jm.DataType.FLOAT, shape=(N,))
-        >>> x = jm.BinaryVar("x", shape=(N,))
-        >>> i = jm.Element("i", belong_to=N)
-        
-        >>> problem = jm.Problem("problem")
-        >>> problem += jm.sum(i, c[i] * x[i])
-        
-        >>> inputs = problem.generate_random_dataset(
-        ...     options={
-        ...         'N': {"value": builtins.range(10, 20)},
-        ...         'c': {"value": jm.range.value.closed(-1.0, 1.0)}
-        ...          # You can also specify "size" for the range of jagged array dimension size.
-        ...     },
-        ...     seed=123 # omittable
-        ... )
-        >>> assert set(inputs.keys()) == {"N", "c"}
-        >>> inputs
-        {'N': 11.0, 'c': array([ 0.93914459, -0.06511935, -0.7460324 , -0.32443706,  0.99981451,
-               -0.24407535,  0.31329469,  0.52206453, -0.1291936 ,  0.30443087,
-                0.53125838])}
-        
-        ```
-        """
-    def generate_random_instance(self, _default:typing.Any, _options:typing.Any, _seed:typing.Optional[builtins.int], _hints:typing.Optional[typing.Any]) -> typing.Any:
-        r"""
-        Generates random `ommx.v1.Instance` for a given problem.
-        See also `InstanceDataValue.generate_random_dataset`.
-        
-        Args
-        -----
-        - `options` (optional): a dictionary of range parameters for each separate placeholders. The key must be the name of the placeholder and the value must be range parameter (as described in "Range Parameters and Range Syntax" section in :func:`~jijmodeling.Problem.generate_random_dataset`).
-        - `default` (optional): default range parameters for placeholders which is not specified in `options`.
-        - `seed` (optional): seed for random number generation.
-        - `hints` (optional): the hints to be detected during compilation see `Interpreter.eval_problem` for more details.
-        
-        Returns
-        --------
-        `instance`: The OMMX v1 instance object.
-        
-        Examples
-        ---------
-        ```python
-        >>> import jijmodeling as jm
-        >>> import builtins
-        >>> import ommx.v1
-        >>> N = jm.Placeholder("N", dtype=jm.DataType.INTEGER)
-        >>> c = jm.Placeholder("c", dtype=jm.DataType.FLOAT, shape=(N,))
-        >>> x = jm.BinaryVar("x", shape=(N,))
-        >>> i = jm.Element("i", belong_to=N)
-        
-        >>> problem = jm.Problem("problem")
-        >>> problem += jm.sum(i, c[i] * x[i])
-        
-        >>> instance = problem.generate_random_instance(
-        ...     options={
-        ...         'N': {"value": builtins.range(10, 20)},
-        ...         'c': {"value": jm.range.value.closed(-1.0, 1.0)}
-        ...     },
-        ...     seed=123
-        ... )
-        >>> assert type(instance) is ommx.v1.Instance
-        
-        ```
-        """
-    def type_of(self, name:builtins.str) -> Type: ...
-    def infer(self, expr:Expression | builtins.int | builtins.float | DecisionVar | Placeholder | list | tuple | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any]) -> Type: ...
 
 class DesugaredProblemBuilder:
     def __call__(self) -> None: ...
@@ -646,7 +689,7 @@ class Namespace:
     @staticmethod
     def from_problem(problem:Problem) -> Namespace: ...
     def add_placeholder(self, placeholder:Placeholder) -> None: ...
-    def Placeholder(self, name:builtins.str, *, ndim:typing.Optional[builtins.int]=None, shape:typing.Optional[typing.Sequence[Expression | builtins.int | builtins.float | DecisionVar | Placeholder | list | tuple | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any]]]=None, dtype:DataType | type=DataType.FLOAT, jagged:builtins.bool=False, latex:typing.Optional[builtins.str]=None, description:typing.Optional[builtins.str]=None) -> Placeholder: ...
+    def Placeholder(self, name:builtins.str, *, ndim:typing.Optional[builtins.int]=None, shape:typing.Optional[typing.Sequence[Expression | builtins.int | builtins.float | DecisionVar | Placeholder | list | tuple | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any]]]=None, dtype:DataType | type | tuple=DataType.FLOAT, jagged:builtins.bool=False, latex:typing.Optional[builtins.str]=None, description:typing.Optional[builtins.str]=None) -> Placeholder: ...
     def add_decision_var(self, var:DecisionVar) -> None: ...
     def type_of(self, name:builtins.str) -> Type: ...
     def infer(self, expr:Expression | builtins.int | builtins.float | DecisionVar | Placeholder | list | tuple | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any]) -> Type: ...
@@ -716,6 +759,20 @@ class Placeholder:
     Placeholder(name='a', ndim=2, shape=None, dtype=typing.float, jagged=False)
     ```
     """
+    @property
+    def name(self) -> builtins.str: ...
+    @property
+    def ndim(self) -> builtins.int: ...
+    @property
+    def shape(self) -> typing.Optional[builtins.list[Expression]]: ...
+    @property
+    def dtype(self) -> DataType | type | tuple: ...
+    @property
+    def jagged(self) -> builtins.bool: ...
+    @property
+    def description(self) -> typing.Optional[builtins.str]: ...
+    @property
+    def custom_latex(self) -> typing.Optional[builtins.str]: ...
     def __repr__(self) -> builtins.str: ...
     def len_at(self, index:builtins.int) -> Expression: ...
     def __pow__(self, exponent:typing.Any, modulo:typing.Optional[typing.Any]=None) -> Expression: ...
@@ -800,7 +857,7 @@ class Problem:
     def __iadd__(self, other:typing.Any) -> Problem: ...
     def __repr__(self) -> builtins.str: ...
     def eval(self, instance_data:dict) -> ommx.v1.Instance: ...
-    def Placeholder(self, name:builtins.str, *, ndim:typing.Optional[builtins.int]=None, shape:typing.Optional[typing.Sequence[Expression | builtins.int | builtins.float | DecisionVar | Placeholder | list | tuple | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any]]]=None, dtype:DataType | type=DataType.FLOAT, jagged:builtins.bool=False, latex:typing.Optional[builtins.str]=None, description:typing.Optional[builtins.str]=None) -> Placeholder: ...
+    def Placeholder(self, name:builtins.str, *, ndim:typing.Optional[builtins.int]=None, shape:typing.Optional[typing.Sequence[Expression | builtins.int | builtins.float | DecisionVar | Placeholder | list | tuple | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any]]]=None, dtype:DataType | type | tuple=DataType.FLOAT, jagged:builtins.bool=False, latex:typing.Optional[builtins.str]=None, description:typing.Optional[builtins.str]=None) -> Placeholder: ...
     def Integer(self, name:builtins.str, *, ndim:typing.Optional[builtins.int]=None, shape:typing.Optional[typing.Sequence[Expression | builtins.int | builtins.float | DecisionVar | Placeholder | list | tuple | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any]]]=None, jagged:builtins.bool=False, latex:typing.Optional[builtins.str]=None, description:typing.Optional[builtins.str]=None) -> Placeholder:
         r"""
         A shorthand for `Problem.Placeholder(dtype=int)`
@@ -1046,12 +1103,6 @@ class Problem:
         >>> instance = problem.eval(instance_data)
         ```
         """
-    def __new__(cls, name:builtins.str, *, sense:ProblemSense=ProblemSense.MINIMIZE) -> Problem: ...
-    def Constraint(self, name:builtins.str, expression:Expression | builtins.int | builtins.float | DecisionVar | Placeholder | list | tuple | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any], *, description:typing.Optional[builtins.str]=None) -> Constraint:
-        r"""
-        Constructs `Constraint` object, __WITHOUT__ registering it to the problem.
-        Use `+=` operator to register the constraint to the problem.
-        """
     def used_placeholders(self) -> builtins.list[Placeholder]: ...
     def get_problem_schema(self) -> dict:
         r"""
@@ -1192,6 +1243,38 @@ class Problem:
         """
     def type_of(self, name:builtins.str) -> Type: ...
     def infer(self, expr:Expression | builtins.int | builtins.float | DecisionVar | Placeholder | list | tuple | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any]) -> Type: ...
+    def decision_vars(self) -> builtins.dict[builtins.str, DecisionVar]:
+        r"""
+        Returns a dictionary of decision variables in the problem.
+        The dictionary may contain decision variables that are not used in the problem.
+        
+        Returns
+        --------
+        `dict[str, DecisionVar]`: Dictionary mapping variable names to DecisionVar objects.
+        """
+    def placeholders(self) -> builtins.dict[builtins.str, Placeholder]:
+        r"""
+        Returns a dictionary of placeholders in the problem.
+        The dictionary may contain placeholders that are not used in the problem;
+        to get only used placeholders, use `used_placeholders` method.
+        
+        Returns
+        --------
+        `dict[str, Placeholder]`: Dictionary mapping placeholder names to Placeholder objects.
+        """
+    @typing.overload
+    def Constraint(self, name:builtins.str, expression:Expression | builtins.int | builtins.float | DecisionVar | Placeholder | list | tuple | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any], domain:typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any], description:typing.Optional[builtins.str]=None) -> Constraint:
+        r"""
+        Constructs `Constraint` object from index set and function to build comparison expression from each index, __WITHOUT__ registering it to the problem.
+        Use `+=` operator to register the constraint to the problem.
+        """
+    @typing.overload
+    def Constraint(self, name:builtins.str, expression:Expression | builtins.int | builtins.float | DecisionVar | Placeholder | list | tuple | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any], description:typing.Optional[builtins.str]=None) -> Constraint:
+        r"""
+        Constructs `Constraint` object from comparison expression, __WITHOUT__ registering it to the problem.
+        Use `+=` operator to register the constraint to the problem.
+        """
+    def __new__(cls, name:builtins.str, *, sense:ProblemSense=ProblemSense.MINIMIZE) -> Problem: ...
 
 class Type:
     ...
@@ -1202,25 +1285,10 @@ class ConstraintSense(Enum):
     GREATER_THAN_EQUAL = ...
 
 class DataType(Enum):
-    r"""
-    A datatype for JijModeling expressions
-    """
     INTEGER = ...
-    r"""
-    INTEGER
-    """
     FLOAT = ...
-    r"""
-    FLOAT
-    """
     BINARY = ...
-    r"""
-    BINARY
-    """
     NATURAL = ...
-    r"""
-    NATURAL
-    """
 
 class DecisionVarKind(Enum):
     BINARY = ...
@@ -1286,19 +1354,58 @@ def min(lhs:Expression | builtins.int | builtins.float | DecisionVar | Placehold
 
 def neg(expr:Expression | builtins.int | builtins.float | DecisionVar | Placeholder | list | tuple | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any]) -> Expression: ...
 
-def prod(operand:Expression | builtins.int | builtins.float | DecisionVar | Placeholder | list | tuple | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any], axis:typing.Optional[Expression | builtins.int | builtins.float | DecisionVar | Placeholder | list | tuple | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any] | builtins.int | typing.Sequence[Expression | builtins.int | builtins.float | DecisionVar | Placeholder | list | tuple | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any]] | typing.Sequence[builtins.int]]=None) -> Expression: ...
+@typing.overload
+def prod(index:Expression | builtins.int | builtins.float | DecisionVar | Placeholder | list | tuple | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any], operand:typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any]) -> Expression:
+    r"""
+    Takes an index and an operand representing the product operation in positional style. Eg. `jm.prod(N, lambda i: x[i])`
+    """
+
+@typing.overload
+def prod(operand:Expression | builtins.int | builtins.float | DecisionVar | Placeholder | list | tuple | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any], axis:typing.Optional[Expression | builtins.int | builtins.float | DecisionVar | Placeholder | list | tuple | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any]]=None) -> Expression:
+    r"""
+    Takes the product of a set or tensor-like expression. You can use `axis` to partially reducing the tensor along specified axes. Eg. `jm.prod(N.map(lambda i: x[i]))`
+    """
+
+@typing.overload
+def prod(x:typing.Generator[Expression]) -> Expression:
+    r"""
+    Comprehension syntax for jm.prod (NOTE: only works with decorated API!)
+    """
+
+def product(*sets) -> Expression:
+    r"""
+    Takes the cartesian product of given set-like expressions.
+    """
 
 def roll(operand:Expression | builtins.int | builtins.float | DecisionVar | Placeholder | list | tuple | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any], shift:typing.Any, *, axis:typing.Optional[builtins.int]=None) -> Expression: ...
 
 def rows(array:Expression | builtins.int | builtins.float | DecisionVar | Placeholder | list | tuple | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any]) -> Expression: ...
 
+def set(operand:Expression | builtins.int | builtins.float | DecisionVar | Placeholder | list | tuple | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any]) -> Expression: ...
+
 def sin(expr:Expression | builtins.int | builtins.float | DecisionVar | Placeholder | list | tuple | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any]) -> Expression: ...
 
 def sinh(expr:Expression | builtins.int | builtins.float | DecisionVar | Placeholder | list | tuple | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any]) -> Expression: ...
 
 def sqrt(expr:Expression | builtins.int | builtins.float | DecisionVar | Placeholder | list | tuple | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any]) -> Expression: ...
 
-def sum(operand:Expression | builtins.int | builtins.float | DecisionVar | Placeholder | list | tuple | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any], axis:typing.Optional[Expression | builtins.int | builtins.float | DecisionVar | Placeholder | list | tuple | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any] | builtins.int | typing.Sequence[Expression | builtins.int | builtins.float | DecisionVar | Placeholder | list | tuple | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any]] | typing.Sequence[builtins.int]]=None) -> Expression: ...
+@typing.overload
+def sum(index:Expression | builtins.int | builtins.float | DecisionVar | Placeholder | list | tuple | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any], operand:typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any]) -> Expression:
+    r"""
+    Takes an index and an operand representing the summation operation in positional style. Eg. `jm.sum(N, lambda i: x[i])`
+    """
+
+@typing.overload
+def sum(operand:Expression | builtins.int | builtins.float | DecisionVar | Placeholder | list | tuple | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any], axis:typing.Optional[Expression | builtins.int | builtins.float | DecisionVar | Placeholder | list | tuple | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any]]=None) -> Expression:
+    r"""
+    Takes the summation of set or tensor-like expression. You can use `axis` to partially reducing the tensor along specified axes. Eg. `jm.sum(N.map(lambda i: x[i]))`
+    """
+
+@typing.overload
+def sum(x:typing.Generator[Expression]) -> Expression:
+    r"""
+    Comprehension syntax for jm.sum (NOTE: only works with decorated API!)
+    """
 
 def tan(expr:Expression | builtins.int | builtins.float | DecisionVar | Placeholder | list | tuple | typing.Callable[[Expression], typing.Any] | typing.Callable[[Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression], typing.Any] | typing.Callable[[Expression, Expression, Expression, Expression, Expression], typing.Any]) -> Expression: ...
 

{jijmodeling-2.0.0a6.dist-info → jijmodeling-2.0.0a8.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: jijmodeling
-Version: 2.0.0a6
+Version: 2.0.0a8
 Classifier: Development Status :: 5 - Production/Stable
 Classifier: Operating System :: POSIX :: Linux
 Classifier: Operating System :: MacOS

jijmodeling-2.0.0a8.dist-info/RECORD

@@ -0,0 +1,9 @@
+jijmodeling-2.0.0a8.dist-info/METADATA,sha256=3WEnd6KxSHmDdNoKBr8-h07nEo8BVG1erSdySmdXyAc,2479
+jijmodeling-2.0.0a8.dist-info/WHEEL,sha256=UrkgLrDWgBx4QmuqgSO9BFTP7-y0Z0RNPOtiCoqPvXw,107
+jijmodeling-2.0.0a8.dist-info/licenses/LICENSE.txt,sha256=UDoDtHuEfRayMGh1HKVD3OR4lXFmXC4ifF2hQvwwj3w,3449
+jijmodeling/__init__.py,sha256=43DV_WzDxS0n6FseNyfJZ6oQucO31T4qqbz3bx9JMtE,44
+jijmodeling/__init__.pyi,sha256=4wOlffYUien9FafFQi2bHqvGT3uLkmS-93QsckYTNRI,148254
+jijmodeling/_jijmodeling.abi3.so,sha256=6BbaP1PXGZ5d9V7Ufid6FoCxeET8sEk7tL2tSTIO2WI,9023080
+jijmodeling/_jijmodeling.pyi,sha256=9towCfPT8yTmJxvncDdME7ZCeFSSntPxAd_TT_spuXQ,162
+jijmodeling/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+jijmodeling-2.0.0a8.dist-info/RECORD,,

{jijmodeling-2.0.0a6.dist-info → jijmodeling-2.0.0a8.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: maturin (1.9.1)
+Generator: maturin (1.9.2)
 Root-Is-Purelib: false
 Tag: cp38-abi3-manylinux_2_28_aarch64

{jijmodeling-2.0.0a6.dist-info → jijmodeling-2.0.0a8.dist-info}/licenses/LICENSE.txt

@@ -10,7 +10,7 @@ For these Terms and Conditions:
 
 (a) "JijZept Service" means a cloud service for optimization calculation infrastructure provided by Jij Inc.
 (b) "JijZept SDK" represents a set of software tools including "JijZept-Client" and "JijModeling" for developing programs that access the JijZept Services. This term includes sample programs provided by us.
-(c) Company (referred to as either "the Company", "We", "Us" or "Our" in this Agreement) refers to Jij Inc., 1-4-6 Nezu, Bunkyo-Ku, Tokyo 113-0031.
+(c) Company (referred to as either "the Company", "We", "Us" or "Our" in this Agreement) refers to Jij Inc., #403, CIC, 3-3-6 Shibaura, Minato-ku, Tokyo, 108-0023.
 (d) "Access Token" means a token necessary for connecting to the JijZept service.
 
 2. Acknowledgment
@@ -43,4 +43,5 @@ You must enter into a separate JijZept service agreement to access the JijZept S
 (b) The Company shall not be liable for any failure of the Software to operate when the User uses or uses the Software for the User's customer by incorporating or linking it with the User-provided Software.
 (c) The User shall be responsible for confirming and examining the suitability of the relevant foreign laws and regulations applicable to the use of the Software. The Company shall not be liable for any legal liabilities related to the appropriate foreign laws and regulations.
 
-Enacted 1 July 2021.
+Enacted 1 July 2021.
+Updated address on 23 July 2025.

jijmodeling-2.0.0a6.dist-info/RECORD

@@ -1,9 +0,0 @@
-jijmodeling-2.0.0a6.dist-info/METADATA,sha256=2VrFrvyjqXa1xzfguzSVpo9Ixyit-TAVd5r0akUoAVM,2479
-jijmodeling-2.0.0a6.dist-info/WHEEL,sha256=mr1qZox3cYDvZG5vJCnwvnEBrBI82LkztNJzwKJciAs,107
-jijmodeling-2.0.0a6.dist-info/licenses/LICENSE.txt,sha256=T5HdEbP5NWG8fZbvF9pofeteW3HrS30V3_LvtPUHFYM,3400
-jijmodeling/__init__.py,sha256=43DV_WzDxS0n6FseNyfJZ6oQucO31T4qqbz3bx9JMtE,44
-jijmodeling/__init__.pyi,sha256=wS4zwiFzlhbXh0LEiLIuBoli3sn4AvRhtZGd8iRH4k4,140970
-jijmodeling/_jijmodeling.abi3.so,sha256=vGBSekTwJOgxzZ_NNCLxXTUYaAyph8hVs985bUEuoEA,8842672
-jijmodeling/_jijmodeling.pyi,sha256=9towCfPT8yTmJxvncDdME7ZCeFSSntPxAd_TT_spuXQ,162
-jijmodeling/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-jijmodeling-2.0.0a6.dist-info/RECORD,,