from typing import List

# imports
import pytest
from inference.core.workflows.core_steps.models.foundation.seg_preview.v1 import \
    BlockManifest


# Minimal stubs for required classes and constants
class OutputDefinition:
    def __init__(self, name, kind):
        self.name = name
        self.kind = kind

    def __eq__(self, other):
        return (
            isinstance(other, OutputDefinition)
            and self.name == other.name
            and self.kind == other.kind
        )

    def __repr__(self):
        return f"OutputDefinition(name={self.name!r}, kind={self.kind!r})"

INSTANCE_SEGMENTATION_PREDICTION_KIND = "instance_segmentation_prediction"
from inference.core.workflows.core_steps.models.foundation.seg_preview.v1 import \
    BlockManifest

# unit tests

# ----------- BASIC TEST CASES -----------







def test_describe_outputs_outputdefinition_fields():
    # OutputDefinition should have exactly the fields 'name' and 'kind'
    codeflash_output = BlockManifest.describe_outputs(); result = codeflash_output # 6.50μs -> 521ns (1148% faster)
    output = result[0]
    fields = [attr for attr in vars(output)]

def test_describe_outputs_outputdefinition_kind_is_single_element_list():
    # kind should be a list of length 1
    codeflash_output = BlockManifest.describe_outputs(); result = codeflash_output # 5.74μs -> 541ns (961% faster)
    kind = result[0].kind


def test_describe_outputs_list_is_not_modified():
    # Modifying the returned list should not affect future calls
    codeflash_output = BlockManifest.describe_outputs(); result1 = codeflash_output # 5.38μs -> 511ns (953% faster)
    result1.append(OutputDefinition("extra", ["other_kind"]))
    codeflash_output = BlockManifest.describe_outputs(); result2 = codeflash_output # 2.40μs -> 220ns (993% faster)


def test_describe_outputs_no_side_effects():
    # Ensure that OutputDefinition returned is not mutated across calls
    codeflash_output = BlockManifest.describe_outputs(); result1 = codeflash_output # 6.36μs -> 561ns (1034% faster)
    result1[0].name = "changed"
    codeflash_output = BlockManifest.describe_outputs(); result2 = codeflash_output # 2.81μs -> 280ns (902% faster)

def test_describe_outputs_outputdefinition_hashability():
    # OutputDefinition should not be hashable (default __eq__ but no __hash__)
    codeflash_output = BlockManifest.describe_outputs(); result = codeflash_output # 5.56μs -> 501ns (1010% faster)
    with pytest.raises(TypeError):
        hash(result[0])
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.
#------------------------------------------------
from typing import List

# imports
import pytest
from inference.core.workflows.core_steps.models.foundation.seg_preview.v1 import \
    BlockManifest

# Mocking minimal required classes and constants for testing
# These are stand-ins for the actual imports in the original file

class OutputDefinition:
    def __init__(self, name, kind):
        self.name = name
        self.kind = kind

    def __eq__(self, other):
        return isinstance(other, OutputDefinition) and self.name == other.name and self.kind == other.kind

    def __repr__(self):
        return f"OutputDefinition(name={self.name!r}, kind={self.kind!r})"

INSTANCE_SEGMENTATION_PREDICTION_KIND = "instance_segmentation_prediction"

# The function under test, as defined in the provided code
def describe_outputs() -> List[OutputDefinition]:
    return [
        OutputDefinition(
            name="predictions",
            kind=[INSTANCE_SEGMENTATION_PREDICTION_KIND],
        ),
    ]

# ------------------- UNIT TESTS -------------------

# 1. Basic Test Cases