localRepositoryPath = new File(path, "repository").getAbsolutePath();
        }

        try {
            return repositorySystem.createLocalRepository(new File(localRepositoryPath));
        } catch (Exception e) {
            throw new MavenExecutionRequestPopulationException("Cannot create local repository.", e);
        }
    }

    private void baseDirectory(MavenExecutionRequest request) {

你可以在[发行说明](../release-notes.md)中查看可用版本（例如查看当前最新版本）。

## 关于版本 { #about-versions }

遵循语义版本控制约定，任何低于`1.0.0`的版本都可能会添加 breaking changes。

FastAPI 还遵循这样的约定：任何"PATCH"版本更改都是为了bug修复和non-breaking changes。

/// tip | 提示

"PATCH"是最后一个数字，例如，在`0.2.3`中，PATCH版本是`3`。

///

因此，你应该能够固定到如下版本：

```txt
fastapi>=0.45.0,<0.46.0
```

"MINOR"版本中会添加breaking changes和新功能。

/// tip | 提示

                    }
                    catch(IOException e) {
                        return 0;
                    }
                }
               
                void logExecution() {
                    try {
                        Files.write(executionLogPath, "Test executed\\n".getBytes(), StandardOpenOption.CREATE, StandardOpenOption.APPEND);
                    } catch (IOException e) {

            processThreadDump(s -> {
                try {
                    writer.write(s);
                    writer.write('\n');
                } catch (final IOException e) {
                    throw new IORuntimeException(e);
                }
            });
        } catch (final Exception e) {
            logger.warn("Failed to write thread dump: file={}", file, e);
        }
    }

    /**

        level = HttpLoggingInterceptor.Level.BASIC
      }

    val client = clientBuilder.addInterceptor(interceptor).build()

    try {
      client.newCall(request).execute()
    } catch (uhe: UnknownHostException) {
      // expected
    }

    val logs = ShadowLog.getLogsForTag(AndroidPlatform.Tag)
    assertThat(logs.map { it.type }).containsOnly(Log.INFO)
    assertThat(
      logs.map {

    try {
      super.get();
    } catch (ExecutionException e) {
      rethrow(e);
    }
    throw new AssertionError("Unreachable");
  }

  @Override
  public V get(long timeout, TimeUnit unit)
      throws InterruptedException, ExecutionException, TimeoutException {
    try {
      super.get(timeout, unit);
    } catch (ExecutionException e) {
      rethrow(e);
    }

            RegexBasedInterpolator interpolator = new RegexBasedInterpolator();
            try {
                interpolator.addValueSource(new EnvarBasedValueSource());
            } catch (IOException e) {
                // ignored
            }
            interpolator.addValueSource(new MapBasedValueSource(System.getProperties()));

            try {

        if (!Constants.T.equals(scheduledJob.getAvailable())) {
            logger.info("Inactive Job: id={}, name={}", id, scheduledJob.getName());
            try {
                unregister(scheduledJob);
            } catch (final Exception e) {
                if (logger.isDebugEnabled()) {
                    logger.debug("Failed to delete Job: job={}", scheduledJob, e);
                }
            }
            return;
        }

      try {
        realRun();
      } catch (Throwable t) {
        threadUnexpectedException(t);
      }
    }
  }

  abstract class CheckedCallable<T> implements Callable<T> {
    abstract T realCall() throws Throwable;

    @Override
    public final T call() {
      try {
        return realCall();
      } catch (Throwable t) {
        threadUnexpectedException(t);

                    } catch (NoSuchFieldException e) {
                        clazz = clazz.getSuperclass();
                    }
                }
                if (field == null) {
                    throw new NoSuchFieldException(fieldName);
                }
                field.setAccessible(true);
                field.set(this, value);
            } catch (Exception e) {