throw new MetadataResolutionException("badly formed edge");
        }
    }
    // ------------------------------------------------------------------------
    public List<MetadataGraphEdge> getEdgesBetween(MetadataGraphVertex vFrom, MetadataGraphVertex vTo) {
        List<MetadataGraphEdge> edges = getIncidentEdges(vTo);
        if (edges == null || edges.isEmpty()) {
            return null;
        }

name: Close linked issues when PR merged into release

on:
  pull_request:
    types: [closed]
    branches:
      - release
      - release7x
      - release8x

permissions:
  issues: write

jobs:
  closeIssueOnPrMerge:
    runs-on: ubuntu-latest
    steps:
      - name: Closes issues related to a merged pull request.
        uses: ldez/gha-mjolnir@df0e84242364946fa3ad4e7556510e8086ad681a
        env:

    private MetadataGraphEdge cleanEdges(
            MetadataGraphVertex v, List<MetadataGraphEdge> edges, ArtifactScopeEnum scope) {
        if (edges == null || edges.isEmpty()) {
            return null;
        }

        if (edges.size() == 1) {
            MetadataGraphEdge e = edges.get(0);
            if (scope.encloses(e.getScope())) {
                return e;
            }

import org.jspecify.annotations.Nullable;

/**
 * A class to represent the set of edges connecting an (implicit) origin node to a target node.
 *
 * <p>The {@link #nodeToOutEdge} map means this class only works on networks without parallel edges.
 * See {@link MultiEdgesConnecting} for a class that works with parallel edges.
 *
 * @author James Sexton
 * @param <E> Edge parameter type
 */
final class EdgesConnecting<E> extends AbstractSet<E> {

  /**
   * Returns the nodes which are the endpoints of {@code edge} in this network.
   *
   * @throws IllegalArgumentException if {@code edge} is not an element of this network
   */
  EndpointPair<N> incidentNodes(E edge);

  /**
   * Returns a live view of the edges which have an {@link #incidentNodes(Object) incident node} in
   * common with {@code edge}. An edge is not considered adjacent to itself.
   *

def get_individual_sponsors(
    settings: Settings,
) -> defaultdict[float, dict[str, SponsorEntity]]:
    nodes: list[SponsorshipAsMaintainerNode] = []
    edges = get_graphql_sponsor_edges(settings=settings)

    while edges:
        for edge in edges:
            nodes.append(edge.node)
        last_edge = edges[-1]

        checkArgument(edges().contains(edge));
        N nodeU = edge.nodeU();
        N nodeV = edge.nodeV();
        Set<EndpointPair<N>> endpointPairIncidentEdges =
            Sets.union(incidentEdges(nodeU), incidentEdges(nodeV));
        return nodePairInvalidatableSet(
            Sets.difference(endpointPairIncidentEdges, ImmutableSet.of(edge)), nodeU, nodeV);
      }

    int edgeStart = graphString.indexOf("edges:");
    String nodeString = graphString.substring(nodeStart, edgeStart);

    Network<N, EndpointPair<N>> asNetwork = graph.asNetwork();
    // Don't call AbstractNetworkTest.validateNetwork(asNetwork).  Mutual recursion.
    assertThat(graph.nodes()).isEqualTo(asNetwork.nodes());
    assertThat(graph.edges()).hasSize(asNetwork.edges().size());

    ImmutableMultimap.Builder<Character, Character> graphMapBuilder = ImmutableMultimap.builder();
    for (String edge : edges) {
      checkArgument(
          edge.length() == 2, "Expecting each edge to consist of 2 characters but got %s", edge);
      char node1 = edge.charAt(0);
      char node2 = edge.charAt(1);
      graphMapBuilder.put(node1, node2);

    int edgeStart = graphString.indexOf("edges:");
    String nodeString = graphString.substring(nodeStart, edgeStart);

    Network<N, EndpointPair<N>> asNetwork = graph.asNetwork();
    // Don't call AbstractNetworkTest.validateNetwork(asNetwork).  Mutual recursion.
    assertThat(graph.nodes()).isEqualTo(asNetwork.nodes());
    assertThat(graph.edges()).hasSize(asNetwork.edges().size());