executable-engineering 0.1.41__py3-none-any.whl → 0.1.43__py3-none-any.whl

executable_engineering/__init__.py

@@ -6,10 +6,17 @@ from .openoptimization_module import OptimizerOpen
 from .gradientoptimization_module import OptimizerGrad
 from .numerical_error_module import python_internal_binary, decimal_to_binary
 from .linearsystems_module import visual_solve_2d, visualize_conditioning, visualize_matrix_norms, jacobi_step, gauss_seidel_step, sor_step, visualize_convergence_2d, create_diagonally_dominant_matrix, iter_solve, steepest_descent, conjugate_gradient, IterationTracker, discretise_poisson, spai
-from .functions_module import weierstrass, plot_and_find_roots, complex_plot_with_shadow, plot_polynomial_roots_companion
+from .functions_module import weierstrass, plot_and_find_roots, complex_plot_with_shadow, plot_polynomial_roots_companion, plot_secant, plot_newton_raphson, plot_basins_of_attraction
+from .optimization_module import visual_golden_section, visual_powell_2d, newton_method
 
 __all__ = [
+  "newton_method",
+  "visual_powell_2d",
+  "visual_golden_section",
   "plot_polynomial_roots_companion",
+  "plot_secant",
+  "plot_newton_raphson",
+  "plot_basins_of_attraction",
   "plot_and_find_roots",
   "complex_plot_with_shadow",
   "weierstrass",

executable_engineering/functions_module.py

@@ -149,3 +149,130 @@ def plot_polynomial_roots_companion(n):
     title = f"Complex Space Plot: Roots of Order {n} Polynomial"
     complex_plot_with_shadow(poly_func, title=title, roots=roots, plot_range=(-plot_limit, plot_limit))
 
+
+def plot_secant(f, x0, x1, tolerance=1e-6, max_iterations=100, title='Secant Method'):
+    import plotly.graph_objects as go
+    import plotly.express as px
+    import numpy as np
+
+    x_values = [x0, x1]
+    for i in range(max_iterations):
+        denom = f(x1) - f(x0)
+        if denom == 0:
+            break
+        x_new = x1 - f(x1) * (x1 - x0) / denom
+        x_values.append(x_new)
+        if abs(f(x_new)) < tolerance:
+            break
+        x0 = x1
+        x1 = x_new
+    
+    root = x_values[-1] if abs(f(x_values[-1])) < tolerance else None
+
+    # Determine plot bounds
+    min_x = min(x_values)
+    max_x = max(x_values)
+    padding = (max_x - min_x) * 0.2 if max_x > min_x else 0.5
+    x = np.linspace(min_x - padding, max_x + padding, 100)
+    
+    fig = go.Figure()
+    fig.add_trace(go.Scatter(x=x, y=f(x), mode='lines', name='f(x)'))
+    fig.add_trace(go.Scatter(x=[x_values[0], x_values[1]], y=[f(x_values[0]), f(x_values[1])], mode='markers', name='Initial guesses'))
+    
+    colors = px.colors.qualitative.Plotly
+    
+    for i in range(1, len(x_values) - 1):
+        # Secant line intersecting x-axis
+        fig.add_trace(go.Scatter(x=[x_values[i-1], x_values[i], x_values[i+1]], y=[f(x_values[i-1]), f(x_values[i]), 0], mode='lines', line=dict(dash='dash', color='gray'), showlegend=False))
+        # Vertical dotted line to the curve
+        fig.add_trace(go.Scatter(x=[x_values[i+1], x_values[i+1]], y=[0, f(x_values[i+1])], mode='lines', line=dict(dash='dot', color='gray'), showlegend=False))
+        
+        color = colors[(i-1) % len(colors)]
+        fig.add_trace(go.Scatter(x=[x_values[i+1]], y=[0], mode='markers', marker=dict(size=10, color=color), name=f'x_{i+1}'))
+    
+    if root:
+        fig.add_trace(go.Scatter(x=[root], y=[0], mode='markers', marker=dict(color='green', size=10), name='Approximate root'))
+    
+    fig.update_layout(title=title, xaxis_title='x', yaxis_title='f(x)')
+    fig.show()
+    return root, x_values
+
+def plot_newton_raphson(f, df, x0, tolerance=1e-6, max_iterations=100, title='Newton-Raphson Method', xrange=None, yrange=None):
+    import plotly.graph_objects as go
+    import plotly.express as px
+    import numpy as np
+    
+    x_values = [x0]
+    for i in range(max_iterations):
+        d = df(x0)
+        if d == 0:
+            break
+        x_new = x0 - f(x0) / d
+        x_values.append(x_new)
+        if abs(f(x_new)) < tolerance or abs(x_new - x0) < tolerance:
+            break
+        x0 = x_new
+
+    root = x_values[-1] if abs(f(x_values[-1])) < tolerance or abs(x_values[-1] - x_values[-2]) < tolerance else None
+
+    # Determine plot bounds
+    if xrange is None:
+        min_x = min(x_values)
+        max_x = max(x_values)
+        padding = (max_x - min_x) * 0.2 if max_x > min_x else 0.5
+        x = np.linspace(min_x - padding, max_x + padding, 100)
+    else:
+        x = np.linspace(xrange[0], xrange[1], 100)
+        
+    fig = go.Figure()
+    fig.add_trace(go.Scatter(x=x, y=f(x), mode='lines', name='f(x)'))
+    fig.add_trace(go.Scatter(x=[x_values[0]], y=[f(x_values[0])], mode='markers', name='Initial guess'))
+    
+    colors = px.colors.qualitative.Plotly
+    
+    for i in range(len(x_values) - 1):
+        # Tangent line intersecting x-axis
+        fig.add_trace(go.Scatter(x=[x_values[i], x_values[i+1]], y=[f(x_values[i]), 0], mode='lines', line=dict(dash='dash', color='gray'), showlegend=False))
+        # Vertical dotted line to the curve
+        fig.add_trace(go.Scatter(x=[x_values[i+1], x_values[i+1]], y=[0, f(x_values[i+1])], mode='lines', line=dict(dash='dot', color='gray'), showlegend=False))
+        
+        color = colors[i % len(colors)]
+        fig.add_trace(go.Scatter(x=[x_values[i+1]], y=[0], mode='markers', marker=dict(size=10, color=color), name=f'x_{i+1}'))
+    
+    if root:
+        fig.add_trace(go.Scatter(x=[root], y=[0], mode='markers', marker=dict(color='green', size=10), name='Approximate root'))
+    
+    fig.update_layout(title=title, xaxis_title='x', yaxis_title='f(x)')
+    if xrange:
+        fig.update_layout(xaxis_range=xrange)
+    if yrange:
+        fig.update_layout(yaxis_range=yrange)
+        
+    fig.show()
+    return root, x_values
+
+def plot_basins_of_attraction(f, df, known_roots, title, real_range=(-2, 2), imag_range=(-2, 2), grid_size=500, th=1e-3):
+    import numpy as np
+    import plotly.graph_objects as go
+    from scipy.optimize import newton
+
+    real_values = np.linspace(real_range[0], real_range[1], grid_size)
+    imag_values = np.linspace(imag_range[0], imag_range[1], grid_size)
+    z_grid = np.array([[complex(r, i) for r in real_values] for i in imag_values])
+
+    roots = newton(f, z_grid, fprime=df)
+
+    colors = np.zeros((grid_size, grid_size))
+    for i in range(grid_size):
+        for j in range(grid_size):
+            if roots[i, j] is None:
+                colors[i, j] = 0
+            else:
+                for idx, r in enumerate(known_roots):
+                    if abs(roots[i, j] - r) < th:
+                        colors[i, j] = idx + 1
+                        break
+                        
+    fig = go.Figure(data=go.Heatmap(z=colors, x=real_values, y=imag_values, colorscale='Viridis', showscale=False))
+    fig.update_layout(title=title, xaxis_title='Real', yaxis_title='Imaginary', width=600, height=600)
+    fig.show()

executable_engineering/optimization_module.py

@@ -0,0 +1,561 @@
+import numpy as np
+import plotly.graph_objects as go
+from scipy.optimize import minimize_scalar
+from scipy.linalg import solve
+
+
+def visual_golden_section(f, x1, x3, tol=1e-5, max_iter=None):
+
+    phi = (1 + np.sqrt(5)) / 2
+    invphi = 1 / phi
+
+    states = []
+    all_evals = []
+
+    initial_width = abs(x3 - x1)
+
+    if initial_width <= tol:
+        required_iter = 0
+    else:
+        required_iter = int(
+            np.ceil(np.log(tol / initial_width) / np.log(invphi))
+        )
+
+    if max_iter is not None:
+        required_iter = min(required_iter, max_iter)
+
+    curr_x1 = x1
+    curr_x3 = x3
+
+    curr_x2 = curr_x3 - invphi * (curr_x3 - curr_x1)
+    curr_x4 = curr_x1 + invphi * (curr_x3 - curr_x1)
+
+    f1 = f(curr_x1)
+    f3 = f(curr_x3)
+    f2 = f(curr_x2)
+    f4 = f(curr_x4)
+
+    all_evals.extend([
+        curr_x1,
+        curr_x2,
+        curr_x4,
+        curr_x3
+    ])
+
+    states.append({
+        'iter': 0,
+        'active': [
+            (curr_x1, f1, 'x1'),
+            (curr_x2, f2, 'x2'),
+            (curr_x4, f4, 'x4'),
+            (curr_x3, f3, 'x3')
+        ],
+        'history': list(dict.fromkeys(all_evals))
+    })
+
+    for i in range(1, required_iter + 1):
+
+        if abs(curr_x3 - curr_x1) <= tol:
+            break
+
+        if f4 < f2:
+
+            curr_x1, f1 = curr_x2, f2
+            curr_x2, f2 = curr_x4, f4
+
+            curr_x4 = curr_x1 + invphi * (curr_x3 - curr_x1)
+            f4 = f(curr_x4)
+
+            all_evals.append(curr_x4)
+
+        else:
+
+            curr_x3, f3 = curr_x4, f4
+            curr_x4, f4 = curr_x2, f2
+
+            curr_x2 = curr_x3 - invphi * (curr_x3 - curr_x1)
+            f2 = f(curr_x2)
+
+            all_evals.append(curr_x2)
+
+        states.append({
+            'iter': i,
+            'active': [
+                (curr_x1, f1, 'x1'),
+                (curr_x2, f2, 'x2'),
+                (curr_x4, f4, 'x4'),
+                (curr_x3, f3, 'x3')
+            ],
+            'history': list(dict.fromkeys(all_evals))
+        })
+
+    x_min = min(all_evals)
+    x_max = max(all_evals)
+
+    margin = (x_max - x_min) * 0.15
+
+    if margin == 0:
+        margin = 1
+
+    x_vals = np.linspace(
+        x_min - margin,
+        x_max + margin,
+        400
+    )
+
+    y_vals = f(x_vals)
+
+    fig = go.Figure()
+
+    fig.add_trace(go.Scatter(
+        x=x_vals,
+        y=y_vals,
+        mode='lines',
+        name='f(x)',
+        line=dict(
+            color='lightgray',
+            width=2
+        ),
+        hoverinfo='skip'
+    ))
+
+    init_state = states[0]
+
+    ax = [pt[0] for pt in init_state['active']]
+    ay = [pt[1] for pt in init_state['active']]
+    alabels = [pt[2] for pt in init_state['active']]
+
+    hx = [
+        x for x in init_state['history']
+        if x not in ax
+    ]
+
+    hy = [f(x) for x in hx]
+
+    fig.add_trace(go.Scatter(
+        x=hx,
+        y=hy,
+        mode='markers',
+        name='Past Evaluations',
+        marker=dict(
+            color='gray',
+            size=7,
+            opacity=0.5
+        )
+    ))
+
+    fig.add_trace(go.Scatter(
+        x=ax,
+        y=ay,
+        mode='markers+text',
+        name='Active Bracket',
+        text=alabels,
+        textposition='top center',
+        textfont=dict(
+            color='black',
+            size=13
+        ),
+        marker=dict(
+            color='crimson',
+            size=12,
+            symbol='circle',
+            line=dict(
+                color='black',
+                width=1
+            )
+        )
+    ))
+
+    frames = []
+
+    for state in states:
+
+        cur_ax = [pt[0] for pt in state['active']]
+        cur_ay = [pt[1] for pt in state['active']]
+        cur_alabels = [pt[2] for pt in state['active']]
+
+        cur_hx = [
+            x for x in state['history']
+            if x not in cur_ax
+        ]
+
+        cur_hy = [f(x) for x in cur_hx]
+
+        frames.append(
+            go.Frame(
+                data=[
+                    go.Scatter(
+                        x=cur_hx,
+                        y=cur_hy
+                    ),
+                    go.Scatter(
+                        x=cur_ax,
+                        y=cur_ay,
+                        text=cur_alabels
+                    )
+                ],
+                name=f"Iter {state['iter']}",
+                traces=[1, 2]
+            )
+        )
+
+    fig.frames = frames
+
+    sliders = [{
+        "active": 0,
+        "y": -0.05,
+        "yanchor": "top",
+        "xanchor": "left",
+        "currentvalue": {
+            "font": {
+                "size": 16
+            },
+            "prefix": "Step: ",
+            "visible": True,
+            "xanchor": "right"
+        },
+        "transition": {
+            "duration": 0
+        },
+        "pad": {
+            "b": 10,
+            "t": 20
+        },
+        "steps": [
+            {
+                "args": [
+                    [frame.name],
+                    {
+                        "frame": {
+                            "duration": 0,
+                            "redraw": True
+                        },
+                        "mode": "immediate"
+                    }
+                ],
+                "label": str(k),
+                "method": "animate"
+            }
+            for k, frame in enumerate(frames)
+        ]
+    }]
+
+    updatemenus = [{
+        "buttons": [
+            {
+                "args": [
+                    None,
+                    {
+                        "frame": {
+                            "duration": 600,
+                            "redraw": True
+                        },
+                        "fromcurrent": True
+                    }
+                ],
+                "label": "Play",
+                "method": "animate"
+            },
+            {
+                "args": [
+                    [None],
+                    {
+                        "frame": {
+                            "duration": 0,
+                            "redraw": True
+                        },
+                        "mode": "immediate"
+                    }
+                ],
+                "label": "Pause",
+                "method": "animate"
+            }
+        ],
+        "direction": "left",
+        "pad": {
+            "r": 10,
+            "t": 10
+        },
+        "showactive": False,
+        "type": "buttons",
+        "x": 0.5,
+        "xanchor": "center",
+        "y": -0.32,
+        "yanchor": "top"
+    }]
+
+    fig.update_layout(
+        title=(
+            f"Golden Section Search"
+        ),
+        xaxis_title="x",
+        yaxis_title="f(x)",
+        width=800,
+        height=620,
+        margin=dict(
+            l=25,
+            r=25,
+            t=50,
+            b=160
+        ),
+        plot_bgcolor='white',
+        xaxis=dict(
+            showgrid=True,
+            gridcolor='#eaeaea'
+        ),
+        yaxis=dict(
+            showgrid=True,
+            gridcolor='#eaeaea'
+        ),
+        updatemenus=updatemenus,
+        sliders=sliders
+    )
+
+    return fig
+  
+
+def visual_powell_2d(
+    f,
+    point0,
+    h1=(1, 0),
+    h2=(0, 1),
+    tol=1e-6,
+    max_iter=100
+):
+
+
+    point = np.array(point0, dtype=float)
+    h1 = np.array(h1, dtype=float)
+    h2 = np.array(h2, dtype=float)
+
+    def evaluate(pt):
+        return f(pt[0], pt[1])
+
+    def line_search(pt, direction):
+        if np.linalg.norm(direction) < 1e-12:
+            return pt.copy()
+
+        res = minimize_scalar(
+            lambda alpha: evaluate(pt + alpha * direction),
+            method="brent"
+        )
+
+        return pt + res.x * direction
+
+    
+    points = [point.copy()]
+
+    directions = [h1, h2]
+
+    converged = False
+
+
+    for iteration in range(max_iter):
+
+        iteration_start = point.copy()
+        f_start = evaluate(point)
+
+        for direction in directions:
+            point = line_search(point, direction)
+            points.append(point.copy())
+
+        new_direction = point - iteration_start
+
+        if np.linalg.norm(new_direction) < tol:
+            converged = True
+            break
+
+        point_before_new_direction = point.copy()
+
+        point = line_search(point, new_direction)
+        points.append(point.copy())
+
+        f_new = evaluate(point)
+
+        point_change = np.linalg.norm(
+            point - point_before_new_direction
+        )
+
+        objective_change = abs(f_new - f_start)
+
+        if point_change < tol and objective_change < tol:
+            converged = True
+            break
+
+        directions = [
+            directions[1],
+            new_direction
+        ]
+
+    x_coords = [p[0] for p in points]
+    y_coords = [p[1] for p in points]
+
+    labels = [str(i) for i in range(len(points))]
+
+    labels[-1] = "Min"
+
+    padding = 2.0
+
+    x_min = min(x_coords) - padding
+    x_max = max(x_coords) + padding
+
+    y_min = min(y_coords) - padding
+    y_max = max(y_coords) + padding
+
+    x_values = np.linspace(x_min, x_max, 200)
+    y_values = np.linspace(y_min, y_max, 200)
+
+    X, Y = np.meshgrid(x_values, y_values)
+
+    Z = np.zeros_like(X)
+
+    for i in range(X.shape[0]):
+        for j in range(X.shape[1]):
+            Z[i, j] = f(X[i, j], Y[i, j])
+
+    fig = go.Figure()
+
+    fig.add_trace(
+        go.Contour(
+            x=x_values,
+            y=y_values,
+            z=Z,
+            colorscale="Blues_r",
+            showscale=False,
+            contours=dict(
+                start=np.min(Z),
+                end=np.max(Z),
+                size=(np.max(Z) - np.min(Z)) / 15
+            ),
+            line=dict(width=1),
+            name="Objective Contour"
+        )
+    )
+
+    fig.add_trace(
+        go.Scatter(
+            x=x_coords,
+            y=y_coords,
+            mode="lines",
+            name="Search Path",
+            line=dict(
+                color="black",
+                width=2
+            )
+        )
+    )
+
+    fig.add_trace(
+        go.Scatter(
+            x=x_coords,
+            y=y_coords,
+            mode="markers+text",
+            name="Evaluation Points",
+            text=labels,
+            textposition="top center",
+            textfont=dict(
+                size=12,
+                color="black"
+            ),
+            marker=dict(
+                color=["black"] * (len(points) - 1) + ["red"],
+                size=[8] * (len(points) - 1) + [14],
+                symbol=["circle"] * (len(points) - 1) + ["star"]
+            ),
+            hoverinfo="text",
+            hovertext=[
+                (
+                    f"Point {label}"
+                    f"<br>x: {x:.6f}"
+                    f"<br>y: {y:.6f}"
+                    f"<br>f(x,y): {f(x, y):.6f}"
+                )
+                for label, x, y in zip(
+                    labels,
+                    x_coords,
+                    y_coords
+                )
+            ]
+        )
+    )
+
+    if converged:
+        title = (
+            f"Powell's Method: Converged "
+            f"({iteration + 1} iterations)"
+        )
+    else:
+        title = (
+            f"Powell's Method: Maximum Iterations Reached "
+            f"({max_iter} iterations)"
+        )
+
+    fig.update_layout(
+        title=title,
+        xaxis_title="x",
+        yaxis_title="y",
+        width=800,
+        height=600,
+        margin=dict(
+            l=25,
+            r=25,
+            t=50,
+            b=25
+        ),
+        plot_bgcolor="white"
+    )
+
+    return fig
+  
+
+def newton_method(f, grad_f, hessian_f, x0, tol=1e-6, max_iter=100):
+  x = x0
+  print(x)
+  guesses = [x]
+  for _ in range(max_iter):
+    grad = grad_f(x)
+    hess = hessian_f(x)
+
+    # ~~ What goes here?
+
+    ###
+    delta_x = solve(hess, -grad, assume_a = 'sym')
+    ###
+    x = x + delta_x
+    guesses.append(x)
+    print(x)
+    if np.linalg.norm(grad) < tol:
+      break
+
+  # Create a surface plot of the function
+  x = np.linspace(-2, 2, 100)
+  y = np.linspace(-2, 2, 100)
+  X, Y = np.meshgrid(x, y)
+  Z = f([X, Y])
+
+  fig = go.Figure(data=[go.Surface(x=X, y=Y, z=Z)])
+
+  # Add markers for each guess
+  for guess in guesses:
+    fig.add_trace(go.Scatter3d(
+        x=[guess[0]],
+        y=[guess[1]],
+        z=[f(guess)],
+        mode='markers',
+        marker=dict(
+            size=5,
+            color='red'
+        )
+    ))
+
+  fig.update_layout(
+      title='Newton\'s Method Optimization',
+      scene=dict(
+          xaxis_title='x',
+          yaxis_title='y',
+          zaxis_title='f(x,y)'
+      )
+  )
+  fig.show()
+
+

{executable_engineering-0.1.41.dist-info → executable_engineering-0.1.43.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: executable_engineering
-Version: 0.1.41
+Version: 0.1.43
 Summary: Demonstrative tools for the Executable Engineering textbook
 Home-page: https://github.com/themintlab/ExecutableEngineering/tree/main/executable_engineering
 Author: Michael Welland

{executable_engineering-0.1.41.dist-info → executable_engineering-0.1.43.dist-info}/RECORD

@@ -1,15 +1,16 @@
-executable_engineering/__init__.py,sha256=-Pcd1x1O6zkA2ro9iz6RLgeq68yNQyV4aPBhNjQSKx4,1887
+executable_engineering/__init__.py,sha256=p_BjWnXnCdd_g2SUfgn5L9xSEBCjSLDrZV0inHka1Sc,2177
 executable_engineering/closedoptimization_module.py,sha256=i9KkdulyCZmriYKlx0CuUetjoMmxJm9ADWgStU3w85w,9273
 executable_engineering/closedrootfinder_module.py,sha256=hQ6iWNi16RkZTaE_WPUEwkohmrYrAyU8WWSXO2EPLJY,6000
-executable_engineering/functions_module.py,sha256=NsPFoVwd3h7zsyW3QFTGZxciKyLQP1vepvmwXP2GQ20,5164
+executable_engineering/functions_module.py,sha256=HmZacKzSpUtjM1BLzAoXAgnARhQXizJcWeL7zZnO5zM,10473
 executable_engineering/gradientoptimization_module.py,sha256=-2fErE9cemSEPeV9PlWOf4cF7Tr6DjilEw_NxvE-JYw,6601
 executable_engineering/linearsystems_module.py,sha256=w6UkwZu80gUz5bAIWY47xJbwaEVzR9tCcIBkMsKjIRk,18356
 executable_engineering/neuralnet_module.py,sha256=Hu9QFoMyODg4RCEpHmT9zTwzjcVFYM8ZLYtbB3CbrsA,10102
 executable_engineering/numerical_error_module.py,sha256=wxfYP8u29c19I2D6MxpQV3zDMV0DpS1QUqFpp3f6eGE,1204
 executable_engineering/openoptimization_module.py,sha256=OCPyrynkTo1It50RoT7irnL72aQn6FexE_R1SfFYxlg,8590
 executable_engineering/openrootfinder_module.py,sha256=R_lPtCQsIGLXV-j_uDpQepImOOgtgA7I6qnhUPwWLLc,5944
-executable_engineering-0.1.41.dist-info/licenses/LICENSE,sha256=Tg4nrt8rFhgpkPbIA8SWoCR3MlGLw0NufB8AE6-TH_o,1074
-executable_engineering-0.1.41.dist-info/METADATA,sha256=ayq_EWUXT-C5IuQrx1ys-RVtBFoOk6oN5WpCdazWAwE,1648
-executable_engineering-0.1.41.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
-executable_engineering-0.1.41.dist-info/top_level.txt,sha256=0U5ATV5WGTLvN9rRSjQ54TyL-ztTyXaN3FzZ_QMq4HM,23
-executable_engineering-0.1.41.dist-info/RECORD,,
+executable_engineering/optimization_module.py,sha256=qFKdksJxeU4WZ9CDKs9lF-kn-FIHUx9DhifRprlATHo,12315
+executable_engineering-0.1.43.dist-info/licenses/LICENSE,sha256=Tg4nrt8rFhgpkPbIA8SWoCR3MlGLw0NufB8AE6-TH_o,1074
+executable_engineering-0.1.43.dist-info/METADATA,sha256=OEali3wRbahuFRUapelVMCs-TLz2p36HbsV_5QNbBYg,1648
+executable_engineering-0.1.43.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+executable_engineering-0.1.43.dist-info/top_level.txt,sha256=0U5ATV5WGTLvN9rRSjQ54TyL-ztTyXaN3FzZ_QMq4HM,23
+executable_engineering-0.1.43.dist-info/RECORD,,