### Implement GUI Layout with Constraints

Source: https://context7.com/nucleic/kiwi/llms.txt

A comprehensive example showing how to define widget dimensions, margins, and alignment constraints using Kiwi, and how to handle dynamic window resizing.

```python
from kiwisolver import Solver, Variable, strength

solver = Solver()
left, top, width, height = Variable("left"), Variable("top"), Variable("width"), Variable("height")

# Define constraints
solver.addConstraint(left >= 0)
solver.addConstraint(width >= 0)
solver.addConstraint(contents_left == left + 10)

# Dynamic resizing
solver.addEditVariable(width, "strong")
solver.suggestValue(width, 200)
solver.updateVariables()
```

--------------------------------

### Installation

Source: https://context7.com/nucleic/kiwi/llms.txt

Instructions for installing the kiwisolver Python package using pip or conda, and including the C++ library as a CMake dependency.

```APIDOC
## Installation

Install Kiwi using pip or conda for Python, or include as a CMake dependency for C++.

```bash
# Python installation via pip
pip install kiwisolver

# Python installation via conda
conda install kiwisolver

# Verify installation
python -c "import kiwisolver; print(kiwisolver.__version__)"
```

```cmake
# C++ installation via CMake FetchContent
include(FetchContent)

FetchContent_Declare(
    kiwi
    GIT_REPOSITORY https://github.com/nucleic/kiwi
    GIT_TAG        1.4.2
)

FetchContent_MakeAvailable(kiwi)

target_link_libraries(your_target PRIVATE kiwi::kiwi)
```
```

--------------------------------

### Install Kiwi Library

Source: https://context7.com/nucleic/kiwi/llms.txt

Instructions for installing the Kiwi library using Python package managers or integrating it into C++ projects via CMake.

```bash
pip install kiwisolver
conda install kiwisolver
python -c "import kiwisolver; print(kiwisolver.__version__)"
```

```cmake
include(FetchContent)

FetchContent_Declare(
    kiwi
    GIT_REPOSITORY https://github.com/nucleic/kiwi
    GIT_TAG        1.4.2
)

FetchContent_MakeAvailable(kiwi)

target_link_libraries(your_target PRIVATE kiwi::kiwi)
```

--------------------------------

### Managing Constraints with Kiwi Solver

Source: https://context7.com/nucleic/kiwi/llms.txt

Demonstrates how to initialize a solver, define variables, add and remove constraints, and update variable values. This pattern is used for static layout systems where constraints are defined and solved incrementally.

```python
from kiwisolver import Solver, Variable

solver = Solver()
x = Variable("x")
y = Variable("y")

solver.addConstraint(x + y == 10)
solver.addConstraint(x - y == 4)

solver.updateVariables()
print(f"x = {x.value()}")
print(f"y = {y.value()}")

c = x >= 0
solver.addConstraint(c)
solver.removeConstraint(c)
solver.reset()
```

```cpp
#include <kiwi/kiwi.h>
#include <iostream>

int main() {
    using namespace kiwi;
    Solver solver;
    Variable x("x");
    Variable y("y");
    solver.addConstraint(x + y == 10);
    solver.addConstraint(x - y == 4);
    solver.updateVariables();
    std::cout << "x = " << x.value() << std::endl;
    std::cout << "y = " << y.value() << std::endl;
    Constraint c = x >= 0;
    solver.addConstraint(c);
    solver.removeConstraint(c);
    solver.reset();
    return 0;
}
```

--------------------------------

### Dynamic Value Suggestions with Edit Variables

Source: https://context7.com/nucleic/kiwi/llms.txt

Shows how to use edit variables to suggest values dynamically, which is more efficient than rebuilding constraints for frequent updates like GUI resizing. It demonstrates setting strengths and updating the system state.

```python
from kiwisolver import Solver, Variable

solver = Solver()
xm = Variable("xm")
xl = Variable("xl")
xr = Variable("xr")

solver.addConstraint(2 * xm == xl + xr)
solver.addConstraint(xl + 20 <= xr)
solver.addEditVariable(xm, "strong")
solver.addEditVariable(xl, "weak")
solver.addEditVariable(xr, "weak")

solver.suggestValue(xm, 40)
solver.updateVariables()
print(f"xm={xm.value()}, xl={xl.value()}, xr={xr.value()}")
```

```cpp
#include <kiwi/kiwi.h>
#include <iostream>

int main() {
    using namespace kiwi;
    Solver solver;
    Variable xm("xm");
    Variable xl("xl");
    Variable xr("xr");
    solver.addConstraint(2 * xm == xl + xr);
    solver.addConstraint(xl + 20 <= xr);
    solver.addEditVariable(xm, strength::strong);
    solver.addEditVariable(xl, strength::weak);
    solver.addEditVariable(xr, strength::weak);
    solver.suggestValue(xm, 40);
    solver.updateVariables();
    std::cout << "xm=" << xm.value() << ", xl=" << xl.value() << ", xr=" << xr.value() << std::endl;
    return 0;
}
```

--------------------------------

### Define and Apply Constraints

Source: https://context7.com/nucleic/kiwi/llms.txt

Shows how to create linear constraints with specific strengths and add them to a solver instance to manage variable relationships.

```python
from kiwisolver import Variable, Solver

x = Variable("x")
y = Variable("y")

c1 = x + y == 10
c2 = x >= 0
c3 = y <= 100
c4 = 2 * x + 3 * y == 30
c5 = x - y >= 5

c_weak = (x == 50) | "weak"
c_medium = (y == 25) | "medium"
c_strong = (x >= 10) | "strong"
c_required = (x >= 0) | "required"

solver = Solver()
solver.addConstraint(c1)
solver.addConstraint((x == 5) | "weak")
solver.updateVariables()

print(c1.expression())
print(c1.op())
print(c1.strength())
print(c1.violated())
```

```cpp
#include <kiwi/kiwi.h>
#include <iostream>

int main() {
    using namespace kiwi;

    Variable x("x");
    Variable y("y");

    Constraint c1 = x + y == 10;
    Constraint c2 = x >= 0;
    Constraint c3 = y <= 100;
    Constraint c4 = 2 * x + 3 * y == 30;

    Constraint c_weak = (x == 50) | strength::weak;
    Constraint c_medium = (y == 25) | strength::medium;
    Constraint c_strong = (x >= 10) | strength::strong;
    Constraint c_required = (x >= 0) | strength::required;

    Solver solver;
    solver.addConstraint(c1);
    solver.addConstraint((x == 5) | strength::weak);
    solver.updateVariables();

    std::cout << "Strength: " << c1.strength() << std::endl;
    std::cout << "Violated: " << (c1.violated() ? "yes" : "no") << std::endl;

    return 0;
}
```

--------------------------------

### Basic C++ Constraint Solving with Kiwi

Source: https://github.com/nucleic/kiwi/blob/main/README.md

Demonstrates the basic usage of the Kiwi C++ API for solving a system of linear equations. It initializes a solver, defines variables, adds constraints, updates variables, and prints the results.

```cpp
#include <kiwi/kiwi.h>
#include <iostream>

int main() {
    // initialize the solver
    kiwi::Solver solver;
    // initialize the variables
    kiwi::Variable x = kiwi::Variable("x");
    kiwi::Variable y = kiwi::Variable("y");
    solver.addConstraint(x + y == 10);
    solver.addConstraint(x - y == 4);
    // solve the system of equations
    solver.updateVariables();
    std::cout << "x: " << x.value() << ", y: " << y.value() << std::endl;
    // Output: x: 7, y: 3
    return 0;
}
```

--------------------------------

### Applying Constraint Strengths

Source: https://context7.com/nucleic/kiwi/llms.txt

Demonstrates how to apply different strengths to constraints, ranging from required to custom values. This allows the solver to prioritize certain constraints over others when conflicts arise.

```python
from kiwisolver import Solver, Variable, strength
solver = Solver()
v1 = Variable("v1")
v2 = Variable("v2")
solver.addConstraint(v1 + v2 == 0)
solver.addConstraint(v1 == 10)
solver.addConstraint((v2 >= 0) | "weak")
solver.addConstraint((v1 <= 20) | strength.medium)
solver.updateVariables()
print(f"v1={v1.value()}, v2={v2.value()}")
```

```cpp
#include <kiwi/kiwi.h>
#include <iostream>
int main() {
    using namespace kiwi;
    Solver solver;
    Variable v1("v1"), v2("v2");
    solver.addConstraint(v1 + v2 == 0);
    solver.addConstraint(v1 == 10);
    solver.addConstraint((v2 >= 0) | strength::weak);
    solver.addConstraint((v1 <= 20) | strength::medium);
    solver.updateVariables();
    std::cout << "v1=" << v1.value() << ", v2=" << v2.value() << std::endl;
    return 0;
}
```

--------------------------------

### Define and Manage Variables

Source: https://context7.com/nucleic/kiwi/llms.txt

Demonstrates creating named and anonymous variables, renaming them, and associating them with context objects in both Python and C++.

```python
from kiwisolver import Variable

x = Variable("x")
y = Variable("y")
width = Variable("width")
height = Variable("height")

anon = Variable()

print(x.name())
x.setName("new_name")
print(x.value())

class WidgetContext:
    def __init__(self, widget_id):
        self.widget_id = widget_id

x.setContext(WidgetContext("button1"))
ctx = x.context()
```

```cpp
#include <kiwi/kiwi.h>
#include <iostream>

int main() {
    using namespace kiwi;

    Variable x("x");
    Variable y("y");
    Variable width("width");

    Variable anon;

    std::cout << x.name() << std::endl;
    x.setName("new_x");
    std::cout << x.value() << std::endl;

    return 0;
}
```

--------------------------------

### Configure Kiwi Test Suite with CMake

Source: https://github.com/nucleic/kiwi/blob/main/tests/CMakeLists.txt

This CMake script enables testing, fetches the GoogleTest framework from GitHub, and defines the kiwi_tests executable. It links the Kiwi library and GoogleTest, then registers the tests for discovery.

```cmake
enable_testing()
include(FetchContent)
FetchContent_Declare(
  googletest
  GIT_REPOSITORY https://github.com/google/googletest.git
  GIT_TAG v1.16.0
)
FetchContent_MakeAvailable(googletest)

set(sources
    SimplexTest.cpp
    VariableTest.cpp
    TermTest.cpp
    ExpressionTest.cpp
    ConstraintTest.cpp
    StrengthTest.cpp
    SolverTest.cpp
)

add_executable(kiwi_tests)
target_compile_features(kiwi_tests PRIVATE cxx_std_23)
target_sources(kiwi_tests PRIVATE ${sources})

target_link_libraries(
    kiwi_tests
    kiwi::kiwi
    GTest::gtest_main
)

include(GoogleTest)
gtest_discover_tests(kiwi_tests)
```

--------------------------------

### Handle Kiwi Solver Exceptions

Source: https://context7.com/nucleic/kiwi/llms.txt

Demonstrates how to catch and handle common exceptions such as DuplicateEditVariable, BadRequiredStrength, and UnknownEditVariable when interacting with the solver.

```python
solver.addEditVariable(v, "weak")
try:
    solver.addEditVariable(v, "medium")
except DuplicateEditVariable as e:
    print(f"Duplicate edit variable: {e.edit_variable}")

solver.reset()
try:
    solver.addEditVariable(v, "required")
except BadRequiredStrength:
    print("Edit variables cannot have required strength")

solver.reset()
try:
    solver.suggestValue(v, 10)
except UnknownEditVariable as e:
    print(f"Not an edit variable: {e.edit_variable}")
```

```cpp
try {
    solver.addConstraint(c);
} catch (const DuplicateConstraint& e) {
    std::cout << "Duplicate: " << e.what() << std::endl;
}
try {
    solver.addConstraint(v <= 5);
} catch (const UnsatisfiableConstraint& e) {
    std::cout << "Unsatisfiable: " << e.what() << std::endl;
}
try {
    solver.addEditVariable(v, strength::required);
} catch (const BadRequiredStrength& e) {
    std::cout << "Bad strength: " << e.what() << std::endl;
}
```

--------------------------------

### Create Custom Strengths in C++

Source: https://github.com/nucleic/kiwi/blob/main/docs/source/basis/solver_internals.md

Demonstrates the creation of custom strengths in C++ for the Kiwi solver. Similar to Python, strengths are represented as floating-point numbers, and a weight can be applied as an optional fourth argument.

```cpp
double my_strength = strength::create(1, 1, 1);
double my_strength = strength::create(1, 1, 1, 2);
```

--------------------------------

### Include Kiwi in C++ Project with CMake

Source: https://github.com/nucleic/kiwi/blob/main/README.md

This snippet shows how to integrate the Kiwi constraint solver into a C++ project using CMake. It utilizes FetchContent to download and build Kiwi, and then links the target library.

```cmake
include(FetchContent)

FetchContent_Declare(
    kiwi
    GIT_REPOSITORY https://github.com/nucleic/kiwi
    GIT_TAG        {release name}
)

FetchContent_MakeAvailable(kiwi)

target_link_libraries(your_target PRIVATE kiwi::kiwi)
```

--------------------------------

### Inspect Kiwi Solver State

Source: https://github.com/nucleic/kiwi/blob/main/docs/source/basis/solver_internals.md

Demonstrates how to inspect the state of the Kiwi solver by dumping its representation to stdout or a string. Understanding the Cassowary algorithm is beneficial for analyzing the output, which includes objective, tableau, infeasible constraints, variables, and edit variables.

```text
Objective
---------
-2 + 2 * e2 + 1 * s8 + -2 * s10

Tableau
-------
v1 | 1 + 1 * s10
e3 | -1 + 1 * e2 + -1 * s10
v4 | -1 + -1 * d5 + -1 * s10
s6 | -2 + -1 * s10
e9 | -1 + 1 * s8 + -1 * s10

Infeasible
----------
e3
e9

Variables
---------
bar = v1
foo = v4

Edit Variables
--------------
bar

Constraints
-----------
1 * bar + -0 >= 0  | strength = 1
1 * bar + 1 <= 0  | strength = 1.001e+09
1 * foo + 1 * bar + 0 == 0  | strength = 1.001e+09
1 * bar + 0 == 0  | strength = 1
```

--------------------------------

### Create Custom Strengths in Kiwi

Source: https://github.com/nucleic/kiwi/blob/main/docs/source/basis/solver_internals.md

Shows how to create custom strengths in Kiwi using the strength.create method. Kiwi uses floating-point numbers for strengths, prioritizing speed over Cassowary's lexicographic ordering. Custom strengths can include a weight as a fourth argument.

```python
from kiwisolver import strength

my_strength = strength.create(1, 1, 1)
my_strength2 = strength.create(1, 1, 1, 2)
```

```python
weak = strength.create(0, 0, 1)
medium = strength.create(0, 1, 0)
strong = strength.create(1, 0, 0)
required = strength.create(1000, 1000, 1000)
```

--------------------------------

### Handling Solver Exceptions

Source: https://context7.com/nucleic/kiwi/llms.txt

Demonstrates how to catch specific exceptions like DuplicateConstraint or UnsatisfiableConstraint to manage errors during the constraint solving process.

```python
from kiwisolver import Solver, Variable, DuplicateConstraint, UnsatisfiableConstraint
solver = Solver()
v = Variable("v")
c = v >= 0
solver.addConstraint(c)
try:
    solver.addConstraint(c)
except DuplicateConstraint as e:
    print(f"Error: {e}")
```

--------------------------------

### Kiwisolver Classes and Methods

Source: https://github.com/nucleic/kiwi/blob/main/docs/source/api/python.md

Documentation for the main classes and their methods within the Kiwisolver library.

```APIDOC
## Kiwisolver Classes and Methods

### *class* kiwisolver.Constraint

Bases: `object`

#### expression()

Get the expression object for the constraint.

#### op()

Get the relational operator for the constraint.

#### strength()

Get the strength for the constraint.

#### violated()

Return whether or not the constraint was violated during the last solver pass.

### *class* kiwisolver.Expression

Bases: `object`

#### constant()

Get the constant for the expression.

#### terms()

Get the tuple of terms for the expression.

#### value()

Get the value for the expression.

### *class* kiwisolver.Solver

Bases: `object`

#### addConstraint()

Add a constraint to the solver.

#### addEditVariable()

Add an edit variable to the solver.

#### dump()

Dump a representation of the solver internals to stdout.

#### dumps()

Dump a representation of the solver internals to a string.

#### hasConstraint()

Check whether the solver contains a constraint.

#### hasEditVariable()

Check whether the solver contains an edit variable.

#### removeConstraint()

Remove a constraint from the solver.

#### removeEditVariable()

Remove an edit variable from the solver.

#### reset()

Reset the solver to the initial empty starting condition.

#### suggestValue()

Suggest a desired value for an edit variable.

#### updateVariables()

Update the values of the solver variables.

### *class* kiwisolver.Term

Bases: `object`

#### coefficient()

Get the coefficient for the term.

#### value()

Get the value for the term.

#### variable()

Get the variable for the term.

### *class* kiwisolver.Variable

Bases: `object`

#### context()

Get the context object associated with the variable.

#### name()

Get the name of the variable.

#### setContext()

Set the context object associated with the variable.

#### setName()

Set the name of the variable.

#### value()

Get the current value of the variable.
```

--------------------------------

### Define Variables for Kiwi Solver

Source: https://github.com/nucleic/kiwi/blob/main/docs/source/basis/basic_systems.md

Initializes variables that the solver will use to determine values. Naming variables is recommended for better error reporting.

```python
from kiwisolver import Variable

x1 = Variable('x1')
x2 = Variable('x2')
xm = Variable('xm')
```

```cpp
#include <kiwi/kiwi.h>

using namespace kiwi;

Variable x1("x1");
Variable x2("x2");
Variable xm("xm");
```

--------------------------------

### Configure and Suggest Edit Variables

Source: https://github.com/nucleic/kiwi/blob/main/docs/source/basis/basic_systems.md

Adds an edit variable to the solver to allow dynamic value suggestions. This is useful for interactive systems like GUI layouts where values change frequently.

```python
solver.addEditVariable(xm, 'strong')
solver.suggestValue(xm, 60)
```

```cpp
solver.addEditVariable(xm, strength::strong);
solver.suggestValue(xm, 60);
```

--------------------------------

### Define and Add Constraints to Solver

Source: https://github.com/nucleic/kiwi/blob/main/docs/source/basis/basic_systems.md

Creates a set of equality or inequality constraints and registers them with the solver instance. Redundant constraints are allowed, but duplicate additions should be avoided.

```python
from kiwisolver import Solver

constraints = [x1 >= 0, x2 <= 100, x2 >= x1 + 10, xm == (x1 + x2) / 2]
solver = Solver()

for cn in constraints:
    solver.addConstraint(cn)
```

```cpp
Solver solver;
Constraint constraints[] = { Constraint {x1 >= 0},
                             Constraint {x2 <= 100},
                             Constraint {x2 >= x1 + 20},
                             Constraint {xm == (x1 + x2) / 2}
                            };

for(auto& constraint : constraints)
{
    solver.addConstraint(constraint);
}
```

--------------------------------

### Defining Constraint Strengths

Source: https://context7.com/nucleic/kiwi/llms.txt

Explains how to utilize built-in constraint strengths and create custom ones. Strengths determine the priority of constraints when the solver attempts to satisfy the system.

```python
from kiwisolver import Solver, Variable, strength

print(strength.required)
print(strength.strong)

custom_medium = strength.create(0, 1, 0, 1.25)
strong_medium = strength.create(0, 100, 0)
```

--------------------------------

### Update Solver Variables in Python and C++

Source: https://github.com/nucleic/kiwi/blob/main/docs/source/basis/basic_systems.md

Demonstrates how to suggest a value for an edit variable and then update the solver's variables to reflect this change. This is necessary because variable values are not automatically updated after a solve. The code shows the equivalent operations in both Python and C++.

```Python
solver.suggestValue(xm, 90)
solver.updateVariables()
print(xm.value(), x1.value(), x2.value())
```

```C++
solver.suggestValue(xm, 90);
solver.updateVariables();
std::cout << xm.value() << ", " << x1.value() << ", " << x2.value();
```

--------------------------------

### Constraint Class

Source: https://context7.com/nucleic/kiwi/llms.txt

Explains how to define constraints using equality and inequality operators, assign strengths (weak, medium, strong, required), and access constraint properties in Python and C++.

```APIDOC
## Constraint

Constraints define relationships between variables using equality (==) or inequality (>=, <=) operators. Each constraint has an associated strength determining its priority during solving.

```python
from kiwisolver import Variable, Solver

x = Variable("x")
y = Variable("y")

# Create constraints using operators
c1 = x + y == 10           # Equality constraint
c2 = x >= 0                # Greater-than-or-equal
c3 = y <= 100              # Less-than-or-equal
c4 = 2 * x + 3 * y == 30   # Linear combination
c5 = x - y >= 5            # Difference constraint

# Constraint with strength using | operator
c_weak = (x == 50) | "weak"
c_medium = (y == 25) | "medium"
c_strong = (x >= 10) | "strong"
c_required = (x >= 0) | "required"  # Must be satisfied

# Access constraint properties
solver = Solver()
solver.addConstraint(c1)
solver.addConstraint((x == 5) | "weak")
solver.updateVariables()

print(c1.expression())     # Get the expression
print(c1.op())             # Get relational operator (OP_EQ, OP_GE, OP_LE)
print(c1.strength())       # Get strength value
print(c1.violated())       # Check if constraint was violated after solving
```

```cpp
#include <kiwi/kiwi.h>
#include <iostream>

int main() {
    using namespace kiwi;

    Variable x("x");
    Variable y("y");

    // Create constraints
    Constraint c1 = x + y == 10;
    Constraint c2 = x >= 0;
    Constraint c3 = y <= 100;
    Constraint c4 = 2 * x + 3 * y == 30;

    // Constraint with strength using | operator
    Constraint c_weak = (x == 50) | strength::weak;
    Constraint c_medium = (y == 25) | strength::medium;
    Constraint c_strong = (x >= 10) | strength::strong;
    Constraint c_required = (x >= 0) | strength::required;

    // Access constraint properties
    Solver solver;
    solver.addConstraint(c1);
    solver.addConstraint((x == 5) | strength::weak);
    solver.updateVariables();

    std::cout << "Strength: " << c1.strength() << std::endl;
    std::cout << "Violated: " << (c1.violated() ? "yes" : "no") << std::endl;

    return 0;
}
```
```

--------------------------------

### Variable Class

Source: https://context7.com/nucleic/kiwi/llms.txt

Demonstrates the creation and manipulation of Variable objects in both Python and C++, including naming, renaming, and associating context objects.

```APIDOC
## Variable

The Variable class represents an unknown value that the solver will determine. Variables can be named (recommended for debugging) and optionally associated with a context object.

```python
from kiwisolver import Variable

# Create named variables (recommended)
x = Variable("x")
y = Variable("y")
width = Variable("width")
height = Variable("height")

# Create anonymous variable
anon = Variable()

# Variable methods
print(x.name())        # "x"
x.setName("new_name")  # Rename variable
print(x.value())       # 0.0 (before solving)

# Variables can have an associated context object
class WidgetContext:
    def __init__(self, widget_id):
        self.widget_id = widget_id

x.setContext(WidgetContext("button1"))
ctx = x.context()  # Retrieve context
```

```cpp
#include <kiwi/kiwi.h>
#include <iostream>

int main() {
    using namespace kiwi;

    // Create named variables
    Variable x("x");
    Variable y("y");
    Variable width("width");

    // Create anonymous variable
    Variable anon;

    // Variable methods
    std::cout << x.name() << std::endl;  // "x"
    x.setName("new_x");
    std::cout << x.value() << std::endl; // 0.0 (before solving)

    return 0;
}
```
```

--------------------------------

### Accessing Expressions and Terms

Source: https://context7.com/nucleic/kiwi/llms.txt

Explains how to inspect the internal structure of a constraint by accessing its expression and the constituent terms, including coefficients and variable values.

```python
from kiwisolver import Solver, Variable
solver = Solver()
v = Variable("v")
c = 2 * v + 1 >= 0
solver.addConstraint(c)
expr = c.expression()
print(f"Expression value: {expr.value()}")
for term in expr.terms():
    print(f"Term coefficient: {term.coefficient()}")
```

--------------------------------

### Kiwisolver Exceptions

Source: https://github.com/nucleic/kiwi/blob/main/docs/source/api/python.md

Details on the exceptions raised by the Kiwisolver library.

```APIDOC
## Kiwisolver Exceptions

### *exception* kiwisolver.BadRequiredStrength

Bases: `Exception`

### *exception* kiwisolver.DuplicateConstraint(constraint)

Bases: `Exception`

#### constraint

### *exception* kiwisolver.DuplicateEditVariable(edit_variable)

Bases: `Exception`

#### edit_variable

### *exception* kiwisolver.UnknownConstraint(constraint)

Bases: `Exception`

#### constraint

### *exception* kiwisolver.UnknownEditVariable(edit_variable)

Bases: `Exception`

#### edit_variable

### *exception* kiwisolver.UnsatisfiableConstraint(constraint)

Bases: `Exception`

#### constraint
```

--------------------------------

### Debugging Solver State

Source: https://context7.com/nucleic/kiwi/llms.txt

Provides methods to dump the internal state of the solver, including the tableau, objective, and variable mappings, for troubleshooting complex constraint systems.

```python
from kiwisolver import Solver, Variable
solver = Solver()
v1 = Variable("foo")
v2 = Variable("bar")
solver.addConstraint(v1 + v2 == 0)
solver.dump()
state = solver.dumps()
```

```cpp
#include <kiwi/kiwi.h>
int main() {
    kiwi::Solver solver;
    kiwi::Variable v1("foo");
    solver.dump();
    std::string state = solver.dumps();
    return 0;
}
```

--------------------------------

### Manage Constraint Strengths

Source: https://github.com/nucleic/kiwi/blob/main/docs/source/basis/basic_systems.md

Assigns strengths (weak, medium, strong) to constraints that are not strictly required. This allows the solver to prioritize certain constraints over others.

```python
solver.addConstraint((x1 == 40) | "weak")
```

```cpp
solver.addConstraint(x1 == 40 | strength::weak);
```

--------------------------------

### Kiwisolver Solver API

Source: https://github.com/nucleic/kiwi/blob/main/docs/source/api/index.md

The Solver class is the core component of the Kiwisolver library, responsible for managing constraints and variables to find a solution that satisfies all defined linear constraints.

```APIDOC
## Solver Class

### Description
The Solver class manages the collection of constraints and variables. It provides methods to add, remove, and suggest values for variables to solve the constraint system.

### Methods
- **addConstraint(constraint)**: Adds a constraint to the solver.
- **removeConstraint(constraint)**: Removes a constraint from the solver.
- **addEditVariable(variable, strength)**: Adds an edit variable to the solver.
- **removeEditVariable(variable)**: Removes an edit variable from the solver.
- **suggestValue(variable, value)**: Suggests a new value for an edit variable.
- **updateVariables()**: Updates the values of all variables based on the current constraints.

### Parameters
- **constraint** (Constraint) - Required - The linear constraint object to be added or removed.
- **variable** (Variable) - Required - The variable object to be edited.
- **strength** (float) - Required - The strength of the edit constraint.
- **value** (float) - Required - The target value for the edit variable.
```

=== COMPLETE CONTENT === This response contains all available snippets from this library. No additional content exists. Do not make further requests.