return conflictResolver.resolveConflicts(getGraph(), ArtifactScopeEnum.compile);
        } else if (requestType.equals(MetadataResolutionRequestTypeEnum.classpathRuntime)) {
            return conflictResolver.resolveConflicts(getGraph(), ArtifactScopeEnum.runtime);
        } else if (requestType.equals(MetadataResolutionRequestTypeEnum.classpathTest)) {
            return conflictResolver.resolveConflicts(getGraph(), ArtifactScopeEnum.test);

        dependsOn(task3, [task4])
        dependsOn(transform1, [task4])

        when:
        collector.collectNodes([task1, task2, task3, task4, transform1])
        def graph = collector.getGraph()
        def nodes = graph.getNodes(PlannedNodeGraph.DetailLevel.LEVEL1_TASKS) as List<TestPlannedNode>
        then:
        nodes.size() == 4
        nodes*.nodeIdentity*.nodeType =~ [NodeType.TASK]
        verifyAll {

                    plannedNodes.add(plannedNode);
                }
            }
        }

        public PlannedNodeGraph getGraph() {
            return new PlannedNodeGraph(detailLevel, plannedNodes);
        }

        private List<? extends NodeIdentity> findNodeDependencies(Node node) {

            PlannedNodeGraph.Collector collector = new PlannedNodeGraph.Collector(converterRegistry);
            scheduledWork.visitNodes((nodes, entryNodes) -> collector.collectNodes(nodes));
            return collector.getGraph();
        }

        private static class CalculateTaskGraphResult implements Result, CustomOperationTraceSerialization {

            private final Set<Task> requestedTasks;

    Subgraph& subgraph = entry.second;
    FixupSourceAndSinkEdges(subgraph.GetGraph());
  }

  if (VLOG_IS_ON(1)) {
    // Dump subgraphs.
    for (auto& entry : subgraphs_) {
      DumpGraphToFile(
          absl::StrCat("encapsulate_subgraphs_subgraph_", entry.first),
          *entry.second.GetGraph(), library);
    }
  }

  return s;
}

Status Encapsulator::BuildFunctionDefs(

                end();
                body();
                    h2().text("Flaky report for " + history.getDisplayName()).end();
                    getGraphs(history).forEach(graph -> graph.render(this));
                end();
            end();
        }
        };
        // @formatter:on
    }

import java.util.List;
import java.util.stream.IntStream;

import static java.util.stream.Collectors.toList;

public interface PerformanceExecutionGraphRenderer {
    default List<ExecutionGraph> getGraphs(PerformanceTestHistory history) {
        List<PerformanceTestExecution> executions = history.getExecutions()
            .stream()
            .filter(this::sameCommit)
            .filter(this::hasTwoDataLines)

                renderExecutions();
            }

            private void renderExecutions() {
                h3().text("Executions for commit " + Git.current().getCommitId()).end();
                getGraphs(testHistory).forEach(graph -> graph.render(this));
            }
        };
    }
    // @formatter:on

    private static class Chart {
        private String field;
        private String label;

        assumes layers only ever have one positional argument. This assumption
        doesn't hold true before TF 2.4 either, but is more likely to cause
        issues now.
    *   Code that manually enters `keras.backend.get_graph()` before building a
        functional model is no longer needed.
    *   Start enforcing input shape assumptions when calling Functional API
        Keras models. This may potentially break some users, in case there is a