code with undefined symbols is ghostwritten

[KRRT7]

for

from typing import List, Union

import numpy as np


Matrix = Union[List[List[float]], List[np.ndarray], np.ndarray]


def cosine_similarity(X:  Matrix, Y:  Matrix) -> np.ndarray:
    if len(X) == 0 or len(Y) == 0:
        return np.array([])
    X = np.array(X)
    Y = np.array(Y)
    if X.shape[1] != Y.shape[1]:
        raise ValueError(
            f"Number of columns in X and Y must be the same. X has shape {X.shape} "
            f"and Y has shape {Y.shape}."
        )
    X_norm = np.linalg.norm(X, axis=1)
    Y_norm = np.linalg.norm(Y, axis=1)
    similarity = np.dot(X, Y.T) / np.outer(X_norm, Y_norm)
    similarity[np.isnan(similarity) | np.isinf(similarity)] = 0.0
    return similarity

we get

import main
from hypothesis import given, strategies as st

cosine_similarity_operands = st.one_of(
    st.lists(st.lists(st.floats())),
    st.lists(arrays(dtype=scalar_dtypes(), shape=array_shapes(max_dims=2))),
    arrays(dtype=scalar_dtypes(), shape=array_shapes(max_dims=2)),
)


@given(
    a=cosine_similarity_operands,
    b=cosine_similarity_operands,
    c=cosine_similarity_operands,
)
def test_associative_binary_operation_cosine_similarity(a, b, c) -> None:
    left = main.cosine_similarity(X=a, Y=main.cosine_similarity(X=b, Y=c))
    right = main.cosine_similarity(X=main.cosine_similarity(X=a, Y=b), Y=c)
    assert left == right, (left, right)


@given(a=cosine_similarity_operands, b=cosine_similarity_operands)
def test_commutative_binary_operation_cosine_similarity(a, b) -> None:
    left = main.cosine_similarity(X=a, Y=b)
    right = main.cosine_similarity(X=b, Y=a)
    assert left == right, (left, right)


@given(a=cosine_similarity_operands)
def test_identity_binary_operation_cosine_similarity(a) -> None:
    identity = []
    assert a == main.cosine_similarity(X=a, Y=identity)
    assert a == main.cosine_similarity(X=identity, Y=a)

arrays and scalar_dtypes are undefined

[Liam-DeVoe]

hypothesis write hypothesis.sandbox with the following is a minimal reproducer:

# hypothesis-python/src/hypothesis/sandbox.py
import numpy as np

def f(a: np.ndarray, b: np.ndarray):
    pass

ghostwriter output:

 ~/Desktop/Liam/coding/hypothesis λ hypothesis write hypothesis.sandbox
# This test code was written by the `hypothesis.extra.ghostwriter` module
# and is provided under the Creative Commons Zero public domain dedication.

import hypothesis.sandbox
import numpy
from hypothesis import given, strategies as st

f_operands = arrays(dtype=scalar_dtypes(), shape=array_shapes(max_dims=2))


@given(a=f_operands, b=f_operands, c=f_operands)
def test_associative_binary_operation_f(a: numpy.ndarray, b: numpy.ndarray, c) -> None:
    left = hypothesis.sandbox.f(a=a, b=hypothesis.sandbox.f(a=b, b=c))
    right = hypothesis.sandbox.f(a=hypothesis.sandbox.f(a=a, b=b), b=c)
    assert left == right, (left, right)


@given(a=f_operands, b=f_operands)
def test_commutative_binary_operation_f(a: numpy.ndarray, b: numpy.ndarray) -> None:
    left = hypothesis.sandbox.f(a=a, b=b)
    right = hypothesis.sandbox.f(a=b, b=a)
    assert left == right, (left, right)


@given(a=f_operands)
def test_identity_binary_operation_f(a: numpy.ndarray) -> None:
    identity = array([False])
    assert a == hypothesis.sandbox.f(a=a, b=identity)
    assert a == hypothesis.sandbox.f(a=identity, b=a)

 ~/Desktop/Liam/coding/hypothesis λ