rng.uniform(low=0.0, high=1.0, size=static_input_shape).astype(
            np.float32
        )
    )

    def data_gen() -> repr_dataset.RepresentativeDataset:
      for _ in range(100):
        yield {
            'input_tensor': rng.uniform(
                low=0.0, high=1.0, size=static_input_shape
            ).astype(np.float32)
        }

import spock.lang.Specification

public class TypedNotationConverterTest extends Specification {

    def parser = NotationParserBuilder.toType(Integer).converter(new DummyConverter()).toComposite()

    def "parses object of source type"(){
        expect:
        parser.parseNotation("100") == 100
    }

    def "throws meaningful exception on parse attempt"(){
        when:

// type and protocol number.
type Cookie uint64

// Family returns an address family.
func (c Cookie) Family() int { return int(c >> 48) }

// Type returns a socket type.
func (c Cookie) Type() int { return int(c << 16 >> 32) }

// Protocol returns a protocol number.
func (c Cookie) Protocol() int { return int(c & 0xff) }

func cookie(family, sotype, proto int) Cookie {

    }

    public static NotationParser<Object, Spec<DependencyResult>> parser() {
        return NotationParserBuilder
                .toType(new TypeInfo<Spec<DependencyResult>>(Spec.class))
                .invalidNotationMessage("Please check the input for the DependencyInsight.dependency element.")

        this.stringInterner = stringInterner;
    }

    @Nonnull
    @Override
    public NotationParser<Object, org.gradle.api.artifacts.ClientModule> create() {
        return NotationParserBuilder.toType(org.gradle.api.artifacts.ClientModule.class)
                .fromCharSequence(new DependencyStringNotationConverter<>(instantiator, DefaultClientModule.class, stringInterner))

import org.gradle.plugins.signing.signatory.SignatoryProvider;
import org.gradle.security.internal.BaseSignatoryProvider;
import org.gradle.util.internal.ConfigureUtil;

import static org.codehaus.groovy.runtime.DefaultGroovyMethods.asType;

public interface ConfigurableSignatoryProvider<T extends Signatory> extends BaseSignatoryProvider<T>, SignatoryProvider<T> {
    @Override
    default void configure(SigningExtension settings, Closure closure) {

import javax.annotation.Nullable;

class NativeDependencyNotationParser {
    public static NotationParser<Object, NativeLibraryRequirement> parser() {
        return NotationParserBuilder
                .toType(NativeLibraryRequirement.class)
                .converter(new LibraryConverter())
                .converter(new NativeLibraryRequirementMapNotationConverter())
                .toComposite();
    }

    /**
     * Returns the dependency type id.
     * The id uniquely identifies this <i>dependency type</i>.
     *
     * @return the id of this type, never {@code null}.
     */
    @Nonnull
    String id();

    /**
     * Returns the dependency type language.
     *
     * @return the language of this type, never {@code null}.
     */
    @Nonnull
    Language getLanguage();

    /**

package syntax

import "go/constant"

// A Type represents a type of Go.
// All types implement the Type interface.
// (This type originally lived in types2. We moved it here
// so we could depend on it from other packages without
// introducing an import cycle.)
type Type interface {
	// Underlying returns the underlying type of a type.
	// Underlying types are never Named, TypeParam, or Alias types.
	//

import javax.annotation.Nullable;

public class ExcludeRuleNotationConverter extends MapNotationConverter<ExcludeRule> {

    private static final NotationParser<Object, ExcludeRule> PARSER =
            NotationParserBuilder.toType(ExcludeRule.class).converter(new ExcludeRuleNotationConverter()).toComposite();

    public static NotationParser<Object, ExcludeRule> parser() {
        return PARSER;
    }

    @Override