finally:
        state["context_a"] = "finished a"


async def context_b(state: dict = Depends(context_a)):
    state["context_b"] = "started b"
    try:
        yield state
    finally:
        state["context_b"] = f"finished b with a: {state['context_a']}"


@app.get("/async")
async def get_async(state: str = Depends(asyncgen_state)):
    return state


@app.get("/sync")

        assert request.state.app
        assert request.state.router
        assert request.state.sub_router
        return {"message": "Hello World"}

    assert state.app_startup is False
    assert state.router_startup is False
    assert state.sub_router_startup is False
    assert state.app_shutdown is False
    assert state.router_shutdown is False
    assert state.sub_router_shutdown is False

		state = madmin.DriveStatePermission
	case errors.Is(err, errFaultyDisk):
		state = madmin.DriveStateFaulty
	case errors.Is(err, errDriveIsRoot):
		state = madmin.DriveStateRootMount
	case err == nil:
		state = madmin.DriveStateOk
	default:
		state = fmt.Sprintf("%s (cause: %s)", madmin.DriveStateUnknown, err)
	}

	return state
}

@pytest.fixture(autouse=True)
def reset_state_and_db():
    global fake_database
    global state
    fake_database = initial_fake_database.copy()
    state = initial_state.copy()


client = TestClient(app)


def test_dependency_gets_exception():
    assert state["except"] is False
    assert state["finally"] is False
    response = client.put("/invalid-user/rick", json="Morty")

		}
	}
}

// State returns the current connection status.
func (c *Connection) State() State {
	return State(atomic.LoadUint32((*uint32)(&c.state)))
}

// Stats returns the current connection stats.
func (c *Connection) Stats() madmin.RPCMetrics {
	conn := 0
	if c.State() == StateConnected {
		conn++
	}
	var lastConn time.Time

                    .collect(Collectors.toList());
        }
    }

    @Benchmark
    public int readWithStax(AdditionState state) throws IOException, XMLStreamException {
        int i = 0;
        for (Path pom : state.poms) {
            try (InputStream is = Files.newInputStream(pom)) {
                MavenStaxReader reader = new MavenStaxReader();

		return err
	}
	var state srState
	if !unlinkSelf {
		state = srState{
			Name:                    c.state.Name,
			Peers:                   updatedPeers,
			ServiceAccountAccessKey: c.state.ServiceAccountAccessKey,
		}
	}

	if err := c.saveToDisk(ctx, state); err != nil {
		return errSRBackendIssue(fmt.Errorf("unable to save cluster-replication state to drive on %s: %v", ourName, err))
	}

                switch (state) {
                    case 0:
                        if (c == '\\') {
                            state = 1;
                        } else if (contains(WHITE_SPACE, c)) {
                            // switch to the separator crossing state
                            state = 2;
                        } else if (contains(SEPARATORS, c)) {

                switch (state) {
                    case 0:
                        if (c == '\\') {
                            state = 1;
                        } else if (contains(WHITE_SPACE, c)) {
                            // switch to the separator crossing state
                            state = 2;
                        } else if (contains(SEPARATORS, c)) {

            url
          }
          title
          createdAt
          lastEditedAt
          updatedAt
          state
          reviews(first:100) {
            nodes {
              author {
                login
                avatarUrl
                url
              }
              state
            }
          }
        }
      }
    }
  }
}
"""


class Author(BaseModel):