- iter_json
            - send_text
            - send_bytes
            - send_json
            - close

When a client disconnects, a `WebSocketDisconnect` exception is raised, you can catch it.

You can import it directly form `fastapi`:

```python
from fastapi import WebSocketDisconnect
```

::: fastapi.WebSocketDisconnect

## WebSockets - additional classes

                    .map(e -> new Pair<>(e.getKey(), (String) e.getValue()))
                    .collect(Collectors.toMap(Pair::getFirst, Pair::getSecond)));
            return result;
        } catch (InstantiationException | IllegalAccessException e) {
            final String msg = "Cannot create a new instance: " + entityType.getName();
            throw new IllegalBehaviorStateException(msg, e);
        }
    }

            final FileConfigService fileConfigService = ComponentUtil.getComponent(FileConfigService.class);
            try {
                fileConfig = fileConfigService.getFileConfig(getFileConfigId()).get();
            } catch (final Exception e) {
                logger.warn("File Config {} does not exist.", getFileConfigId(), e);
            }
        }
        return fileConfig;
    }

    @Override
    public String toString() {

            try (InputStream in = Files.newInputStream(userToolchainsFile.toPath())) {
                toolchains = new PersistedToolchains(new MavenToolchainsStaxReader().read(in));
            } catch (Exception e) {
                throw new MisconfiguredToolchainException(
                        "Cannot read toolchains file at " + userToolchainsFile.getAbsolutePath(), e);
            }

        // The class should be serializable as it extends RuntimeException
        assertTrue(exception instanceof java.io.Serializable);
    }

    @Test
    @DisplayName("Should behave correctly in catch blocks")
    void testCatchBlockBehavior() {
        // Test that RuntimeCIFSException can be caught as RuntimeException
        assertThrows(RuntimeException.class, () -> {

      assertFalse(getMap().entrySet().contains(mapEntry(IncomparableType.INSTANCE, v0())));
    } catch (ClassCastException acceptable) {
      // allowed by the spec
    }
  }

  public void testContainsEntryWithIncomparableValue() {
    try {
      assertFalse(getMap().entrySet().contains(mapEntry(k0(), IncomparableType.INSTANCE)));
    } catch (ClassCastException acceptable) {
      // allowed by the spec
    }
  }

      assertFalse(getMap().entrySet().contains(mapEntry(IncomparableType.INSTANCE, v0())));
    } catch (ClassCastException acceptable) {
      // allowed by the spec
    }
  }

  public void testContainsEntryWithIncomparableValue() {
    try {
      assertFalse(getMap().entrySet().contains(mapEntry(k0(), IncomparableType.INSTANCE)));
    } catch (ClassCastException acceptable) {
      // allowed by the spec
    }
  }

            } else {
                System.out.println("All documentation files and anchors from the JSON files were found in the directory.");
            }
        } catch (IOException e) {
            System.err.println("An error occurred during verification: " + e.getMessage());
            throw new RuntimeException("Error during file verification", e);
        }
    }

      Class<T> interfaceType,
      Function<T, ? extends T> wrapperFunction,
      String... expectedMessages) {
    try {
      tester.testForwarding(interfaceType, wrapperFunction);
    } catch (AssertionFailedError expected) {
      for (String message : expectedMessages) {
        assertThat(expected).hasMessageThat().contains(message);
      }
      return;
    }

            throw new IllegalArgumentException("transliteratorId must not be null");
        }
        try {
            this.transliterator = Transliterator.getInstance(transliteratorId);
        } catch (final IllegalArgumentException e) {
            throw new IllegalArgumentException("Invalid transliterator ID: " + transliteratorId, e);
        }
    }

    @Override