class_docstr: Starts a connection to an existing Neptune project.
  
  You can use the Project object to retrieve information about runs, models, and model versions
  within the project.
  
  You can also log (and fetch) metadata common to the whole project, such as information about datasets,
  links to documents, or key project metrics.
  
  Note: If you want to instead create a project, use the
  [`management.create_project()`](https://docs.neptune.ai/api/management/#create_project) function.
  
  You can also use the Project object as a context manager (see examples).
  
  Args:
      project: Name of a project in the form `workspace-name/project-name`.
          If left empty, the value of the NEPTUNE_PROJECT environment variable is used.
      api_token: User's API token.
          If left empty, the value of the NEPTUNE_API_TOKEN environment variable is used (recommended).
      mode: Connection mode in which the tracking will work.
          If left empty, the value of the NEPTUNE_MODE environment variable is used.
          If no value was set for the environment variable, "async" is used by default.
          Possible values are `async`, `sync`, `read-only`, and `debug`.
      flush_period: In the asynchronous (default) connection mode, how often disk flushing is triggered.
          Defaults to 5 (every 5 seconds).
      proxies: Argument passed to HTTP calls made via the Requests library, as dictionary of strings.
          For more information about proxies, see the Requests documentation.
      async_lag_callback: Custom callback which is called if the lag between a queued operation and its
          synchronization with the server exceeds the duration defined by `async_lag_threshold`. The callback
          should take a Project object as the argument and can contain any custom code, such as calling `stop()`
          on the object.
          Note: Instead of using this argument, you can use Neptune's default callback by setting the
          `NEPTUNE_ENABLE_DEFAULT_ASYNC_LAG_CALLBACK` environment variable to `TRUE`.
      async_lag_threshold: In seconds, duration between the queueing and synchronization of an operation.
          If a lag callback (default callback enabled via environment variable or custom callback passed to the
          `async_lag_callback` argument) is enabled, the callback is called when this duration is exceeded.
      async_no_progress_callback: Custom callback which is called if there has been no synchronization progress
          whatsoever for the duration defined by `async_no_progress_threshold`. The callback
          should take a Project object as the argument and can contain any custom code, such as calling `stop()`
          on the object.
          Note: Instead of using this argument, you can use Neptune's default callback by setting the
          `NEPTUNE_ENABLE_DEFAULT_ASYNC_NO_PROGRESS_CALLBACK` environment variable to `TRUE`.
      async_no_progress_threshold: In seconds, for how long there has been no synchronization progress since the
          object was initialized. If a no-progress callback (default callback enabled via environment variable or
          custom callback passed to the `async_no_progress_callback` argument) is enabled, the callback is called
          when this duration is exceeded.
  
  Returns:
      Project object that can be used to interact with the project as a whole,
      like logging or fetching project-level metadata.
  
  Examples:
  
      >>> import neptune
  
      >>> # Connect to the project "classification" in the workspace "ml-team":
      ... project = neptune.init_project(project="ml-team/classification")
  
      >>> # Or initialize with the constructor
      ... project = Project(project="ml-team/classification")
  
      >>> # Connect to a project in read-only mode:
      ... project = neptune.init_project(
      ...     project="ml-team/classification",
      ...     mode="read-only",
      ... )
  
      Using the Project object as context manager:
  
      >>> with Project(project="ml-team/classification") as project:
      ...     project["metadata"] = some_metadata
  
  For more, see the docs:
      Initializing a project:
          https://docs.neptune.ai/api/neptune#init_project
      Project class reference:
          https://docs.neptune.ai/api/project/
code: def _raise_if_stopped(self):
      if self._state == ContainerState.STOPPED:
          raise InactiveProjectException(
              label=f"{self._workspace}/{self._project_name}"
          )
  
imports: import os
  from typing import Iterable, Optional, Union
  from typing_extensions import Literal
  from neptune.common.exceptions import NeptuneException
  from neptune.envs import CONNECTION_MODE
  from neptune.exceptions import InactiveProjectException
  from neptune.internal.backends.api_model import ApiExperiment
  from neptune.internal.backends.nql import NQLAttributeOperator, NQLAttributeType, NQLEmptyQuery, NQLQueryAttribute
  from neptune.internal.container_type import ContainerType
  from neptune.internal.init.parameters import ASYNC_LAG_THRESHOLD, ASYNC_NO_PROGRESS_THRESHOLD, DEFAULT_FLUSH_PERIOD
  from neptune.internal.state import ContainerState
  from neptune.internal.utils import as_list, verify_type
  from neptune.metadata_containers import MetadataContainer
  from neptune.metadata_containers.abstract import NeptuneObjectCallback
  from neptune.metadata_containers.metadata_containers_table import Table
  from neptune.metadata_containers.utils import prepare_nql_query
  from neptune.types.mode import Mode
label_desc: Use image node_id 3 for calling the Project obj's underlying member method code with example usage: obj._raise_if_stopped() without return types