* CharSource CharSource}, {@link ByteSink ByteSink} and {@link CharSink CharSink}. They are
 * factories for I/O streams that provide many convenience methods that handle both opening and
 * closing streams for you.
 *
 * <p>This package is a part of the open-source <a href="https://github.com/google/guava">Guava</a>

import javax.annotation.CheckForNull;

/**
 * Exception thrown upon the failure of a <a
 * href="https://github.com/google/guava/wiki/ConditionalFailuresExplained">verification check</a>,
 * including those performed by the convenience methods of the {@link Verify} class.
 *
 * @since 17.0
 */
@GwtCompatible
@ElementTypesAreNonnullByDefault
public class VerifyException extends RuntimeException {

 * under the License.
 */
package org.apache.maven.artifact;

/**
 * Type safe reincarnation of Artifact scope. Also supplies the {@code DEFAULT_SCOPE} as well
 * as convenience method to deal with scope relationships.
 *
 *
 */
@Deprecated
public enum ArtifactScopeEnum {
    compile(1),
    test(2),
    runtime(3),
    provided(4),
    system(5),
    runtime_plus_system(6);

// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package textproto

import (
	"bufio"
	"fmt"
	"io"
)

// A Writer implements convenience methods for writing
// requests or responses to a text protocol network connection.
type Writer struct {
	W   *bufio.Writer
	dot *dotWriter
}

// NewWriter returns a new [Writer] writing to w.

			req = req.WithContext(context.WithValue(req.Context(), muxAndDiscoveryIncompleteKey, "MuxAndDiscoveryInstallationNotComplete"))
		}
		handler.ServeHTTP(w, req)
	})
}

// isClosed is a convenience function that simply check if the given chan has been closed
func isClosed(ch <-chan struct{}) bool {
	select {
	case <-ch:
		return true
	default:
		return false
	}

!!! note "Technical Details"
    You could also use `from starlette.responses import JSONResponse`.

    **FastAPI** provides the same `starlette.responses` as `fastapi.responses` just as a convenience for you, the developer. But most of the available responses come directly from Starlette. The same with `status`.

## OpenAPI and API docs

	retry.WithCodes(codes.Canceled, codes.DeadlineExceeded, codes.ResourceExhausted, codes.Aborted, codes.Internal, codes.Unavailable),
}

// CARetryInterceptor is a grpc UnaryInterceptor that adds retry options, as a convenience wrapper
// around CARetryOptions. If needed to chain with other interceptors, the CARetryOptions can be used
// directly.
func CARetryInterceptor() grpc.DialOption {

  about every particular db's extension or quirk.

* Separate out the basic implementation of a database driver
  (implementing the sql/driver interfaces) vs the implementation
  of all the user-level types and convenience methods.
  In a nutshell:

  User Code ---> sql package (concrete types) ---> sql/driver (interfaces)
  Database Driver -> sql (to register) + sql/driver (implement interfaces)

  OwningOpRef<ModuleOp> ParseModuleOpString(
      const absl::string_view module_op_str) {
    return parseSourceString<ModuleOp>(module_op_str, ctx_.get());
  }

  // Convenience function that returns the first operation of type `OpT` from
  // the `@main` function in `module_op`. Useful when testing with a text
  // representation of a `ModuleOp` containing a single function `@main`.

See the License for the specific language governing permissions and
limitations under the License.
*/

package winstats

import (
	"fmt"
	"golang.org/x/sys/windows/registry"
)

// OSInfo is a convenience class for retrieving Windows OS information
type OSInfo struct {
	BuildNumber, ProductName        string
	MajorVersion, MinorVersion, UBR uint64
}

// GetOSInfo reads Windows version information from the registry