text:
use std::collections::BTreeMap;

use std::time::Duration;

use ruma_api::ruma_api;
use ruma_identifiers::{DeviceId, UserId};
use serde_json::Value as JsonValue;

use super::{AlgorithmAndDeviceId, KeyAlgorithm, OneTimeKey};

ruma_api! {
    metadata {
        description: "Claims one-time keys for use in pre-key messages.",
        method: POST,
        name: "claim_keys",
        path: "/_matrix/client/r0/keys/claim",
        rate_limited: false,
        requires_authentication: true,
    }

    request {
        /// The time (in milliseconds) to wait when downloading keys from remote servers.
        /// 10 seconds is the recommended default.
        #[serde(
            with = "ruma_serde::duration::opt_ms",
            default,
            skip_serializing_if = "Option::is_none",
        )]
        pub timeout: Option<Duration>,

        /// The keys to be claimed.
        pub one_time_keys: BTreeMap<UserId, BTreeMap<DeviceId, KeyAlgorithm>>,
    }

    response {
        /// If any remote homeservers could not be reached, they are recorded here.
        /// The names of the properties are the names of the unreachable servers.
        pub failures: BTreeMap<String, JsonValue>,

        /// One-time keys for the queried devices.
        pub one_time_keys: BTreeMap<UserId, BTreeMap<DeviceId, BTreeMap<AlgorithmAndDeviceId, OneTimeKey>>>,
    }

    error: crate::Error
}


text:
"""
github3.gists.history
---------------------

Module containing the logic for the GistHistory object.

"""
from __future__ import unicode_literals

from github3.models import GitHubCore
from github3.users import User

class GistHistory(GitHubCore):

    """Thisobject represents one version (or revision) of a gist.

    Two history instances can be checked like so::

        h1 == h2
        h1 != h2

    And is equivalent to::

        h1.version == h2.version
        h1.version != h2.version

    """

    def __init__(self, history, session=None):
        super(GistHistory, self).__init__(history, session)
        self._api = history.get('url', '')

        #: SHA of the commit associated with this version
        self.version = history.get('version', '')

        #: user who made these changes
        self.user = User(history.get('user') or {}, session)

        #: dict containing the change status; see also: deletions, additions,
        #: total
        self.change_status = history.get('change_status', {})

        #: number of additions made
        self.additions = self.change_status.get('additions', 0)

        #: number of deletions made
        self.deletions = self.change_status.get('deletions', 0)

        #: total number of changes made
        self.total = self.change_status.get('total', 0)

        #: datetime representation of when the commit was made
        self.committed_at = self._strptime(history.get('committed_at'))

    def _repr(self):
        return '<Gist History [{0}]>'.format(self.version)

    def get_gist(self):
        """Retrieve the gist at this version.

        :returns: :class:`Gist <github3.gists.gist.Gist>`

        """
        from github3.gists.gist import Gist
        json = self._json(self._get(self._api), 200)
        return Gist(json, self)

redpajama_set_name: RedPajamaGithub


text:
package main

import (
	"os"

	"github.com/coreos/pkg/capnslog"
	"github.com/spf13/cobra"

	"github.com/coreos/mantle/cli"
	"github.com/coreos/mantle/kola/register"

	// Register any tests that we may wish to execute in kolet.
	_ "github.com/coreos/mantle/kola"
)

var (
	plog = capnslog.NewPackageLogger("github.com/coreos/mantle", "kolet")

	root = &cobra.Command{
		Use:   "kolet",
		Short: "Native code runner for kola",
	}

	cmdRun = &cobra.Command{
		Use:   "run",
		Short: "Run a given test's native function",
	}
)

func main() {
	for testName, testObj := range register.Tests {
		if len(testObj.NativeFuncs) == 0 {
			continue
		}
		testCmd := &cobra.Command{
			Use: testName,
		}
		for nativeName := range testObj.NativeFuncs {
			nativeFunc := testObj.NativeFuncs[nativeName]
			nativeRun := func(cmd *cobra.Command, args []string) {
				if len(args) != 0 {
					cmd.Usage()
					os.Exit(2)
				}
				if err := nativeFunc(); err != nil {
					plog.Fatal(err)
				}
				// Explicitly exit successfully.
				os.Exit(0)
			}
			nativeCmd := &cobra.Command{
				Use: nativeName,
				Run: nativeRun,
			}
			testCmd.AddCommand(nativeCmd)
		}
		cmdRun.AddCommand(testCmd)
	}
	root.AddCommand(cmdRun)

	cli.Execute(root)

	// nativeRun always exits so if we are here it we probably just
	// dumped usage/help info and stopped. Must exit with non-zero
	// to prevent bugs from creating false-positives in kola.
	os.Exit(2)
}


text:
var findOne = require('./findOne');

module.exports = function findById(args, done) {
    var search = {_id: args.options.id};

    findOne(args, search, done);
};


text:
<!doctype html>

		<title>Zabuun - Learn Arabic for English Speakers</title>
		<meta name="description" content="">
		<?php include $_SERVER['DOCUMENT_ROOT'].'/layout/head.php';?>

		<?php include $_SERVER['DOCUMENT_ROOT'].'/layout/ie8.php';?>
		<?php include $_SERVER['DOCUMENT_ROOT'].'/layout/header.php';?>

			<?php include $_SERVER['DOCUMENT_ROOT'].'/layout/side.php';?>

						Modern Standard Arabic (MSA) | Egyptian Colloquial Arabic (ECA) | Both

Driving

Asking Dad for a Car

  A: Dad, I don't have my own car.
 B: Your mom and I talked to you about this.
 A: I wasn't paying attention.
 B: We don't have enough money for a new car.
 A: Can't we just take some loans?
 B: You can just use the old car.
 A: It's so ugly though.
 B: Money doesn't grow on trees.
 A: Everyone at school has a new car.
 B: Get a job and buy one yourself.
 A: But no one wants to hire me.
 B: Then you're going to have to drive an old car.

		<?php include $_SERVER['DOCUMENT_ROOT'].'/layout/footer.php';?>
		<?php include $_SERVER['DOCUMENT_ROOT'].'/layout/scripts.php';?>


text:
/* Usage: This provider is used for throttling input data from files. It takes the option "rate" which is the rate in bytes/s for the stream to come in.
 * Example:

 {
   "type": "providers/throttle",
   "options": {
     "rate": 500
   }
 }

 */

const Throttle = require('stream-throttle').Throttle

module.exports = Throttle


text:
package com.digitalpetri.opcua.stack.core.types.structured;

import com.digitalpetri.opcua.stack.core.Identifiers;
import com.digitalpetri.opcua.stack.core.serialization.DelegateRegistry;
import com.digitalpetri.opcua.stack.core.serialization.UaDecoder;
import com.digitalpetri.opcua.stack.core.serialization.UaEncoder;
import com.digitalpetri.opcua.stack.core.serialization.UaStructure;
import com.digitalpetri.opcua.stack.core.types.UaDataType;
import com.digitalpetri.opcua.stack.core.types.builtin.NodeId;
import com.digitalpetri.opcua.stack.core.types.builtin.StatusCode;

@UaDataType("HistoryUpdateEventResult")
public class HistoryUpdateEventResult implements UaStructure {

    public static final NodeId TypeId = Identifiers.HistoryUpdateEventResult;
    public static final NodeId BinaryEncodingId = Identifiers.HistoryUpdateEventResult_Encoding_DefaultBinary;
    public static final NodeId XmlEncodingId = Identifiers.HistoryUpdateEventResult_Encoding_DefaultXml;

    protected final StatusCode _statusCode;
    protected final EventFilterResult _eventFilterResult;

    public HistoryUpdateEventResult() {
        this._statusCode = null;
        this._eventFilterResult = null;
    }

    public HistoryUpdateEventResult(StatusCode _statusCode, EventFilterResult _eventFilterResult) {
        this._statusCode = _statusCode;
        this._eventFilterResult = _eventFilterResult;
    }

    public StatusCode getStatusCode() {
        return _statusCode;
    }

    public EventFilterResult getEventFilterResult() {
        return _eventFilterResult;
    }

    @Override
    public NodeId getTypeId() {
        return TypeId;
    }

    @Override
    public NodeId getBinaryEncodingId() {
        return BinaryEncodingId;
    }

    @Override
    public NodeId getXmlEncodingId() {
        return XmlEncodingId;
    }

    public static void encode(HistoryUpdateEventResult historyUpdateEventResult, UaEncoder encoder) {
        encoder.encodeStatusCode("StatusCode", historyUpdateEventResult._statusCode);
        encoder.encodeSerializable("EventFilterResult", historyUpdateEventResult._eventFilterResult != null ? historyUpdateEventResult._eventFilterResult : new EventFilterResult());
    }

    public static HistoryUpdateEventResult decode(UaDecoder decoder) {
        StatusCode _statusCode = decoder.decodeStatusCode("StatusCode");
        EventFilterResult _eventFilterResult = decoder.decodeSerializable("EventFilterResult", EventFilterResult.class);

        return new HistoryUpdateEventResult(_statusCode, _eventFilterResult);
    }

    static {
        DelegateRegistry.registerEncoder(HistoryUpdateEventResult::encode, HistoryUpdateEventResult.class, BinaryEncodingId, XmlEncodingId);
        DelegateRegistry.registerDecoder(HistoryUpdateEventResult::decode, HistoryUpdateEventResult.class, BinaryEncodingId, XmlEncodingId);
    }

}


text:
using System;
using System.Text.Json;
using System.Threading;
using System.Threading.Tasks;
using Azure;
using Azure.Core;
using Azure.Core.Pipeline;
using Azure.ResourceManager.Cdn.Models;

namespace Azure.ResourceManager.Cdn
{
    internal partial class CdnManagementRestOperations
    {
        private readonly TelemetryDetails _userAgent;
        private readonly HttpPipeline _pipeline;
        private readonly Uri _endpoint;
        private readonly string _apiVersion;

        /// <summary> Initializes a new instance of CdnManagementRestOperations. </summary>
        /// <param name="pipeline"> The HTTP pipeline for sending and receiving REST requests and responses. </param>
        /// <param name="applicationId"> The application id to use for user agent. </param>
        /// <param name="endpoint"> server parameter. </param>
        /// <param name="apiVersion"> Api Version. </param>
        /// <exception cref="ArgumentNullException"> <paramref name="pipeline"/> or <paramref name="apiVersion"/> is null. </exception>
        public CdnManagementRestOperations(HttpPipeline pipeline, string applicationId, Uri endpoint = null, string apiVersion = default)
        {
            _pipeline = pipeline ?? throw new ArgumentNullException(nameof(pipeline));
            _endpoint = endpoint ?? new Uri("https://management.azure.com");
            _apiVersion = apiVersion ?? "2021-06-01";
            _userAgent = new TelemetryDetails(GetType().Assembly, applicationId);
        }

        internal HttpMessage CreateCheckEndpointNameAvailabilityRequest(string subscriptionId, string resourceGroupName, EndpointNameAvailabilityContent content)
        {
            var message = _pipeline.CreateMessage();
            var request = message.Request;
            request.Method = RequestMethod.Post;
            var uri = new RawRequestUriBuilder();
            uri.Reset(_endpoint);
            uri.AppendPath("/subscriptions/", false);
            uri.AppendPath(subscriptionId, true);
            uri.AppendPath("/resourceGroups/", false);
            uri.AppendPath(resourceGroupName, true);
            uri.AppendPath("/providers/Microsoft.Cdn/checkEndpointNameAvailability", false);
            uri.AppendQuery("api-version", _apiVersion, true);
            request.Uri = uri;
            request.Headers.Add("Accept", "application/json");
            request.Headers.Add("Content-Type", "application/json");
            var content0 = new Utf8JsonRequestContent();
            content0.JsonWriter.WriteObjectValue(content);
            request.Content = content0;
            _userAgent.Apply(message);
            return message;
        }

        /// <summary> Check the availability of a resource name. This is needed for resources where name is globally unique, such as a afdx endpoint. </summary>
        /// <param name="subscriptionId"> Azure Subscription ID. </param>
        /// <param name="resourceGroupName"> Name of the Resource group within the Azure subscription. </param>
        /// <param name="content"> Input to check. </param>
        /// <param name="cancellationToken"> The cancellation token to use. </param>
        /// <exception cref="ArgumentNullException"> <paramref name="subscriptionId"/>, <paramref name="resourceGroupName"/> or <paramref name="content"/> is null. </exception>
        /// <exception cref="ArgumentException"> <paramref name="subscriptionId"/> or <paramref name="resourceGroupName"/> is an empty string, and was expected to be non-empty. </exception>
        public async Task<Response<EndpointNameAvailabilityResult>> CheckEndpointNameAvailabilityAsync(string subscriptionId, string resourceGroupName, EndpointNameAvailabilityContent content, CancellationToken cancellationToken = default)
        {
            Argument.AssertNotNullOrEmpty(subscriptionId, nameof(subscriptionId));
            Argument.AssertNotNullOrEmpty(resourceGroupName, nameof(resourceGroupName));
            Argument.AssertNotNull(content, nameof(content));

            using var message = CreateCheckEndpointNameAvailabilityRequest(subscriptionId, resourceGroupName, content);
            await _pipeline.SendAsync(message, cancellationToken).ConfigureAwait(false);
            switch (message.Response.Status)
            {
                case 200:
                    {
                        EndpointNameAvailabilityResult value = default;
                        using var document = await JsonDocument.ParseAsync(message.Response.ContentStream, default, cancellationToken).ConfigureAwait(false);
                        value = EndpointNameAvailabilityResult.DeserializeEndpointNameAvailabilityResult(document.RootElement);
                        return Response.FromValue(value, message.Response);
                    }
                default:
                    throw new RequestFailedException(message.Response);
            }
        }

        /// <summary> Check the availability of a resource name. This is needed for resources where name is globally unique, such as a afdx endpoint. </summary>
        /// <param name="subscriptionId"> Azure Subscription ID. </param>
        /// <param name="resourceGroupName"> Name of the Resource group within the Azure subscription. </param>
        /// <param name="content"> Input to check. </param>
        /// <param name="cancellationToken"> The cancellation token to use. </param>
        /// <exception cref="ArgumentNullException"> <paramref name="subscriptionId"/>, <paramref name="resourceGroupName"/> or <paramref name="content"/> is null. </exception>
        /// <exception cref="ArgumentException"> <paramref name="subscriptionId"/> or <paramref name="resourceGroupName"/> is an empty string, and was expected to be non-empty. </exception>
        public Response<EndpointNameAvailabilityResult> CheckEndpointNameAvailability(string subscriptionId, string resourceGroupName, EndpointNameAvailabilityContent content, CancellationToken cancellationToken = default)
        {
            Argument.AssertNotNullOrEmpty(subscriptionId, nameof(subscriptionId));
            Argument.AssertNotNullOrEmpty(resourceGroupName, nameof(resourceGroupName));
            Argument.AssertNotNull(content, nameof(content));

            using var message = CreateCheckEndpointNameAvailabilityRequest(subscriptionId, resourceGroupName, content);
            _pipeline.Send(message, cancellationToken);
            switch (message.Response.Status)
            {
                case 200:
                    {
                        EndpointNameAvailabilityResult value = default;
                        using var document = JsonDocument.Parse(message.Response.ContentStream);
                        value = EndpointNameAvailabilityResult.DeserializeEndpointNameAvailabilityResult(document.RootElement);
                        return Response.FromValue(value, message.Response);
                    }
                default:
                    throw new RequestFailedException(message.Response);
            }
        }

        internal HttpMessage CreateCheckNameAvailabilityRequest(CdnNameAvailabilityContent content)
        {
            var message = _pipeline.CreateMessage();
            var request = message.Request;
            request.Method = RequestMethod.Post;
            var uri = new RawRequestUriBuilder();
            uri.Reset(_endpoint);
            uri.AppendPath("/providers/Microsoft.Cdn/checkNameAvailability", false);
            uri.AppendQuery("api-version", _apiVersion, true);
            request.Uri = uri;
            request.Headers.Add("Accept", "application/json");
            request.Headers.Add("Content-Type", "application/json");
            var content0 = new Utf8JsonRequestContent();
            content0.JsonWriter.WriteObjectValue(content);
            request.Content = content0;
            _userAgent.Apply(message);
            return message;
        }

        /// <summary> Check the availability of a resource name. This is needed for resources where name is globally unique, such as a CDN endpoint. </summary>
        /// <param name="content"> Input to check. </param>
        /// <param name="cancellationToken"> The cancellation token to use. </param>
        /// <exception cref="ArgumentNullException"> <paramref name="content"/> is null. </exception>
        public async Task<Response<CdnNameAvailabilityResult>> CheckNameAvailabilityAsync(CdnNameAvailabilityContent content, CancellationToken cancellationToken = default)
        {
            Argument.AssertNotNull(content, nameof(content));

            using var message = CreateCheckNameAvailabilityRequest(content);
            await _pipeline.SendAsync(message, cancellationToken).ConfigureAwait(false);
            switch (message.Response.Status)
            {
                case 200:
                    {
                        CdnNameAvailabilityResult value = default;
                        using var document = await JsonDocument.ParseAsync(message.Response.ContentStream, default, cancellationToken).ConfigureAwait(false);
                        value = CdnNameAvailabilityResult.DeserializeCdnNameAvailabilityResult(document.RootElement);
                        return Response.FromValue(value, message.Response);
                    }
                default:
                    throw new RequestFailedException(message.Response);
            }
        }

        /// <summary> Check the availability of a resource name. This is needed for resources where name is globally unique, such as a CDN endpoint. </summary>
        /// <param name="content"> Input to check. </param>
        /// <param name="cancellationToken"> The cancellation token to use. </param>
        /// <exception cref="ArgumentNullException"> <paramref name="content"/> is null. </exception>
        public Response<CdnNameAvailabilityResult> CheckNameAvailability(CdnNameAvailabilityContent content, CancellationToken cancellationToken = default)
        {
            Argument.AssertNotNull(content, nameof(content));

            using var message = CreateCheckNameAvailabilityRequest(content);
            _pipeline.Send(message, cancellationToken);
            switch (message.Response.Status)
            {
                case 200:
                    {
                        CdnNameAvailabilityResult value = default;
                        using var document = JsonDocument.Parse(message.Response.ContentStream);
                        value = CdnNameAvailabilityResult.DeserializeCdnNameAvailabilityResult(document.RootElement);
                        return Response.FromValue(value, message.Response);
                    }
                default:
                    throw new RequestFailedException(message.Response);
            }
        }

        internal HttpMessage CreateCheckNameAvailabilityWithSubscriptionRequest(string subscriptionId, CdnNameAvailabilityContent content)
        {
            var message = _pipeline.CreateMessage();
            var request = message.Request;
            request.Method = RequestMethod.Post;
            var uri = new RawRequestUriBuilder();
            uri.Reset(_endpoint);
            uri.AppendPath("/subscriptions/", false);
            uri.AppendPath(subscriptionId, true);
            uri.AppendPath("/providers/Microsoft.Cdn/checkNameAvailability", false);
            uri.AppendQuery("api-version", _apiVersion, true);
            request.Uri = uri;
            request.Headers.Add("Accept", "application/json");
            request.Headers.Add("Content-Type", "application/json");
            var content0 = new Utf8JsonRequestContent();
            content0.JsonWriter.WriteObjectValue(content);
            request.Content = content0;
            _userAgent.Apply(message);
            return message;
        }

        /// <summary> Check the availability of a resource name. This is needed for resources where name is globally unique, such as a CDN endpoint. </summary>
        /// <param name="subscriptionId"> Azure Subscription ID. </param>
        /// <param name="content"> Input to check. </param>
        /// <param name="cancellationToken"> The cancellation token to use. </param>
        /// <exception cref="ArgumentNullException"> <paramref name="subscriptionId"/> or <paramref name="content"/> is null. </exception>
        /// <exception cref="ArgumentException"> <paramref name="subscriptionId"/> is an empty string, and was expected to be non-empty. </exception>
        public async Task<Response<CdnNameAvailabilityResult>> CheckNameAvailabilityWithSubscriptionAsync(string subscriptionId, CdnNameAvailabilityContent content, CancellationToken cancellationToken = default)
        {
            Argument.AssertNotNullOrEmpty(subscriptionId, nameof(subscriptionId));
            Argument.AssertNotNull(content, nameof(content));

            using var message = CreateCheckNameAvailabilityWithSubscriptionRequest(subscriptionId, content);
            await _pipeline.SendAsync(message, cancellationToken).ConfigureAwait(false);
            switch (message.Response.Status)
            {
                case 200:
                    {
                        CdnNameAvailabilityResult value = default;
                        using var document = await JsonDocument.ParseAsync(message.Response.ContentStream, default, cancellationToken).ConfigureAwait(false);
                        value = CdnNameAvailabilityResult.DeserializeCdnNameAvailabilityResult(document.RootElement);
                        return Response.FromValue(value, message.Response);
                    }
                default:
                    throw new RequestFailedException(message.Response);
            }
        }

        /// <summary> Check the availability of a resource name. This is needed for resources where name is globally unique, such as a CDN endpoint. </summary>
        /// <param name="subscriptionId"> Azure Subscription ID. </param>
        /// <param name="content"> Input to check. </param>
        /// <param name="cancellationToken"> The cancellation token to use. </param>
        /// <exception cref="ArgumentNullException"> <paramref name="subscriptionId"/> or <paramref name="content"/> is null. </exception>
        /// <exception cref="ArgumentException"> <paramref name="subscriptionId"/> is an empty string, and was expected to be non-empty. </exception>
        public Response<CdnNameAvailabilityResult> CheckNameAvailabilityWithSubscription(string subscriptionId, CdnNameAvailabilityContent content, CancellationToken cancellationToken = default)
        {
            Argument.AssertNotNullOrEmpty(subscriptionId, nameof(subscriptionId));
            Argument.AssertNotNull(content, nameof(content));

            using var message = CreateCheckNameAvailabilityWithSubscriptionRequest(subscriptionId, content);
            _pipeline.Send(message, cancellationToken);
            switch (message.Response.Status)
            {
                case 200:
                    {
                        CdnNameAvailabilityResult value = default;
                        using var document = JsonDocument.Parse(message.Response.ContentStream);
                        value = CdnNameAvailabilityResult.DeserializeCdnNameAvailabilityResult(document.RootElement);
                        return Response.FromValue(value, message.Response);
                    }
                default:
                    throw new RequestFailedException(message.Response);
            }
        }

        internal HttpMessage CreateValidateProbeRequest(string subscriptionId, ValidateProbeContent content)
        {
            var message = _pipeline.CreateMessage();
            var request = message.Request;
            request.Method = RequestMethod.Post;
            var uri = new RawRequestUriBuilder();
            uri.Reset(_endpoint);
            uri.AppendPath("/subscriptions/", false);
            uri.AppendPath(subscriptionId, true);
            uri.AppendPath("/providers/Microsoft.Cdn/validateProbe", false);
            uri.AppendQuery("api-version", _apiVersion, true);
            request.Uri = uri;
            request.Headers.Add("Accept", "application/json");
            request.Headers.Add("Content-Type", "application/json");
            var content0 = new Utf8JsonRequestContent();
            content0.JsonWriter.WriteObjectValue(content);
            request.Content = content0;
            _userAgent.Apply(message);
            return message;
        }

        /// <summary> Check if the probe path is a valid path and the file can be accessed. Probe path is the path to a file hosted on the origin server to help accelerate the delivery of dynamic content via the CDN endpoint. This path is relative to the origin path specified in the endpoint configuration. </summary>
        /// <param name="subscriptionId"> Azure Subscription ID. </param>
        /// <param name="content"> Input to check. </param>
        /// <param name="cancellationToken"> The cancellation token to use. </param>
        /// <exception cref="ArgumentNullException"> <paramref name="subscriptionId"/> or <paramref name="content"/> is null. </exception>
        /// <exception cref="ArgumentException"> <paramref name="subscriptionId"/> is an empty string, and was expected to be non-empty. </exception>
        public async Task<Response<ValidateProbeResult>> ValidateProbeAsync(string subscriptionId, ValidateProbeContent content, CancellationToken cancellationToken = default)
        {
            Argument.AssertNotNullOrEmpty(subscriptionId, nameof(subscriptionId));
            Argument.AssertNotNull(content, nameof(content));

            using var message = CreateValidateProbeRequest(subscriptionId, content);
            await _pipeline.SendAsync(message, cancellationToken).ConfigureAwait(false);
            switch (message.Response.Status)
            {
                case 200:
                    {
                        ValidateProbeResult value = default;
                        using var document = await JsonDocument.ParseAsync(message.Response.ContentStream, default, cancellationToken).ConfigureAwait(false);
                        value = ValidateProbeResult.DeserializeValidateProbeResult(document.RootElement);
                        return Response.FromValue(value, message.Response);
                    }
                default:
                    throw new RequestFailedException(message.Response);
            }
        }

        /// <summary> Check if the probe path is a valid path and the file can be accessed. Probe path is the path to a file hosted on the origin server to help accelerate the delivery of dynamic content via the CDN endpoint. This path is relative to the origin path specified in the endpoint configuration. </summary>
        /// <param name="subscriptionId"> Azure Subscription ID. </param>
        /// <param name="content"> Input to check. </param>
        /// <param name="cancellationToken"> The cancellation token to use. </param>
        /// <exception cref="ArgumentNullException"> <paramref name="subscriptionId"/> or <paramref name="content"/> is null. </exception>
        /// <exception cref="ArgumentException"> <paramref name="subscriptionId"/> is an empty string, and was expected to be non-empty. </exception>
        public Response<ValidateProbeResult> ValidateProbe(string subscriptionId, ValidateProbeContent content, CancellationToken cancellationToken = default)
        {
            Argument.AssertNotNullOrEmpty(subscriptionId, nameof(subscriptionId));
            Argument.AssertNotNull(content, nameof(content));

            using var message = CreateValidateProbeRequest(subscriptionId, content);
            _pipeline.Send(message, cancellationToken);
            switch (message.Response.Status)
            {
                case 200:
                    {
                        ValidateProbeResult value = default;
                        using var document = JsonDocument.Parse(message.Response.ContentStream);
                        value = ValidateProbeResult.DeserializeValidateProbeResult(document.RootElement);
                        return Response.FromValue(value, message.Response);
                    }
                default:
                    throw new RequestFailedException(message.Response);
            }
        }
    }
}


text:
<!DOCTYPE html>

    <title>CSS Flipbox</title>
    <meta charset="utf-8" />
<meta http-equiv="x-ua-compatible" content="ie=edge" />
<meta name="viewport" content="width=device-width, initial-scale=1, minimum-scale=1, maximum-scale=1" />

<link rel="stylesheet" type="text/css" href="/css/vendor/reset.min.css" />
<link rel="stylesheet" type="text/css" href="/css/vendor/text.min.css" />
<link rel="stylesheet" type="text/css" href="/css/vendor/github-markdown.min.css" />
<link rel="stylesheet" type="text/css" href="/css/vendor/unsemantic-grid-responsive-tablet-no-ie7.min.css" />
<link rel="stylesheet" type="text/css" href="/css/flipbox.css" />
<link rel="stylesheet" type="text/css" href="/css/styles.css" />

CSS-Flipbox

CSS Only Flip Effect

                        View the Project on GitHub sixertoy/css-flipbox

Download ZIP File

Download TAR Ball

View On GitHub

            Middle horizontal axis

.flipbox.flipbox-page.flipbox-horizontal{
    .flipbox(800px, 320px, 0.6s);
    margin: 60px auto;
    .card-cover{
        background: #ACE539;
    }
    .card-content-top,
    .card-content-bottom{
        background: rgba(0, 0, 0, 0.25);
    }
}

Title background

lorem ipsum dolor sit amet consectuer

            Vertical axis

.flipbox.flipbox-vertical
    .flipbox-extend(740px, 320px, 2s);
    margin: 20px auto;
    .card-cover{
        background: #ACE539;
    }
    .card-content {
        color: #FFF;
        background: rgba(51, 51, 51, 1);
    }
}

Vertical flip axis

<div class="flipbox flipbox-simple flipbox-vertical">
    <div class="wrapper">
        <div class="card card-cover" style="background: url(http://placehold.it/740x320);">
        </div>
        <div class="card card-content">
            <h1><span>Lorem ipsum dolor sit amet</span></h1>
            <p>Consectetur adipiscing elit. Ut ut est metus. Nullam imperdiet efficitur erat non accumsan. In molestie venenatis eros eget ullamcorper. Cras volutpat tellus ornare mattis mattis. Vestibulum vestibulum a orci vestibulum dictum.</p>
        </div>
    </div>
</div>

            Horizontal axis

CSS

HTML

Less

.flipbox.flipbox-horizontal{
    .flipbox-extend(740px, 320px, 2s);
    margin: 20px auto;
    .card-cover{
        background: #ACE539;
    }
    .card-content {
        color: #FFF;
        background: rgba(51, 51, 51, 1);
    }
}

Horizontal flip axis

<div class="flipbox flipbox-simple flipbox-horizontal">
    <div class="wrapper">
        <div class="card card-cover" style="background: url(http://placehold.it/740x320);">
        </div>
        <div class="card card-content">
            <h1><span>Lorem ipsum dolor sit amet</span></h1>
            <p>Consectetur adipiscing elit. Ut ut est metus. Nullam imperdiet efficitur erat non accumsan. In molestie venenatis eros eget ullamcorper. Cras volutpat tellus ornare mattis mattis. Vestibulum vestibulum a orci vestibulum dictum.</p>
        </div>
    </div>
</div>

This project is maintained by sixertoy


text:
package pl.asie.charset.pipes.pipe;

import net.minecraft.nbt.NBTTagCompound;
import net.minecraft.tileentity.TileEntity;
import net.minecraft.util.EnumFacing;
import net.minecraft.util.ITickable;
import net.minecraft.util.math.BlockPos;
import net.minecraftforge.fluids.FluidStack;
import net.minecraftforge.fluids.FluidTankInfo;
import net.minecraftforge.fluids.capability.IFluidHandler;
import net.minecraftforge.fluids.capability.IFluidTankProperties;
import pl.asie.charset.api.pipes.IShifter;
import pl.asie.charset.lib.utils.FluidUtils;
import pl.asie.charset.pipes.ModCharsetPipes;

import javax.annotation.Nullable;

public class PipeFluidContainer implements ITickable {
    private static boolean CAN_BE_DRAINED = false;

    public class Properties implements IFluidTankProperties {
        private final FluidStack stack;
        private final int capacity;

        public Properties(FluidStack stack, int amount, int capacity) {
            if (stack != null) {
                this.stack = stack.copy();
                this.stack.amount = amount;
            } else {
                this.stack = null;
            }
            this.capacity = capacity;
        }

        @Nullable
        @Override
        public FluidStack getContents() {
            return stack;
        }

        @Override
        public int getCapacity() {
            return capacity;
        }

        @Override
        public boolean canFill() {
            return stack == null || stack.amount < capacity;
        }

        @Override
        public boolean canDrain() {
            return CAN_BE_DRAINED && stack != null && stack.amount > 0;
        }

        @Override
        public boolean canFillFluidType(FluidStack fluidStack) {
            return stack == null || (stack.amount < capacity && stack.isFluidEqual(fluidStack));
        }

        @Override
        public boolean canDrainFluidType(FluidStack fluidStack) {
            return CAN_BE_DRAINED && stack != null && stack.amount > 0 && stack.isFluidEqual(fluidStack);
        }
    }

    public class Tank implements IFluidHandler {
        public final EnumFacing location;
        public int amount;
        private boolean dirty;

        public Tank(EnumFacing location) {
            this.location = location;
        }

        public FluidStack getType() {
            return fluidStack;
        }

        public int get() {
            return amount;
        }

        public boolean isDirty() {
            return dirty;
        }

        public boolean removeDirty() {
            if (dirty) {
                dirty = false;
                return true;
            } else {
                return false;
            }
        }

        public int add(int amount, boolean simulate) {
            int targetAmount = Math.min(amount, TANK_SIZE - this.amount);
            if (!simulate && targetAmount > 0) {
                this.amount += targetAmount;
                dirty = true;
            }
            return targetAmount;
        }

        public int remove(int amount, boolean simulate) {
            int targetAmount = Math.min(this.amount, amount);
            if (!simulate && targetAmount > 0) {
                this.amount -= targetAmount;
                dirty = true;
                onRemoval();
            }
            return targetAmount;
        }

        public FluidTankInfo getInfo() {
            FluidStack stack = getType().copy();
            stack.amount = amount;
            return new FluidTankInfo(stack, getCapacity());
        }

        public int getCapacity() {
            return TANK_SIZE;
        }

        @Override
        public IFluidTankProperties[] getTankProperties() {
            return new IFluidTankProperties[]{new Properties(fluidStack, amount, TANK_SIZE)};
        }

        @Override
        public int fill(FluidStack resource, boolean doFill) {
            if (resource == null || resource.amount == 0) {
                return 0;
            }

            if (fluidStack == null) {
                if (doFill) {
                    fluidStack = resource.copy();
                    fluidDirty = true;
                }
            } else if (!fluidStack.isFluidEqual(resource)) {
                return 0;
            }

            return add(resource.amount, !doFill);
        }

        @Nullable
        @Override
        public FluidStack drain(FluidStack resource, boolean doDrain) {
            if (resource == null || resource.amount == 0) {
                return null;
            }

            if (CAN_BE_DRAINED) {
                return fluidStack != null && resource.isFluidEqual(fluidStack) ? drain(resource.amount, doDrain) : null;
            } else {
                return null;
            }
        }

        @Nullable
        @Override
        public FluidStack drain(int maxDrain, boolean doDrain) {
            if (fluidStack == null) {
                return null;
            }

            if (CAN_BE_DRAINED && maxDrain > 0) {
                FluidStack stack = fluidStack.copy();
                int r = remove(maxDrain, !doDrain);
                if (r <= 0) {
                    return null;
                } else {
                    stack.amount = r;
                    return stack;
                }
            } else {
                return null;
            }
        }
    }

    public static final int TANK_RATE = 80;
    final Tank[] tanks = new Tank[7];
    FluidStack fluidStack;
    int fluidColor;
    boolean fluidDirty;

    private static final int TANK_SIZE = 250;
    private final PartPipe owner;

    public PipeFluidContainer(PartPipe owner) {
        this.owner = owner;
        for (int i = 0; i < 7; i++) {
            tanks[i] = new Tank(i < 6 ? EnumFacing.getFront(i) : null);
        }
    }

    public void onRemoval() {
        int total = 0;
        for (Tank t : tanks) {
            total += t.amount;
        }
        if (total == 0) {
            fluidStack = null;
            fluidDirty = true;
        }
    }

    public void writeToNBT(NBTTagCompound nbt) {
        if (fluidStack != null) {
            fluidStack.writeToNBT(nbt);
            int[] amt = new int[7];
            for (int i = 0; i <= 6; i++) {
                amt[i] = tanks[i].amount;
            }
            nbt.setIntArray("TankAmts", amt);
        }
    }

    public void readFromNBT(NBTTagCompound nbt) {
        fluidStack = FluidStack.loadFluidStackFromNBT(nbt);
        fluidDirty = true;
        for (int i = 0; i <= 6; i++) {
            tanks[i].amount = 0;
            tanks[i].dirty = true;
        }

        if (fluidStack != null) {
            int[] amt = nbt.getIntArray("TankAmts");
            if (amt != null && amt.length == 7) {
                for (int i = 0; i <= 6; i++) {
                    tanks[i].amount = Math.min(TANK_SIZE, amt[i]);
                }
            }
        }
    }

    @Override
    public void update() {
        if (owner.getWorld() == null || owner.getWorld().isRemote) {
            return;
        }

        if (fluidStack == null) {
            return;
        }

        EnumFacing pushDir = null;
        int shifterDist = Integer.MAX_VALUE;

        for (EnumFacing facing : EnumFacing.VALUES) {
            if (owner.connects(facing)) {
                int sStr = owner.getShifterStrength(facing);
                if (sStr > 0 && sStr < shifterDist) {
                    IShifter s = owner.getNearestShifter(facing);
                    if (s != null && s.isShifting() && s.matches(fluidStack)) {
                        pushDir = facing;
                        shifterDist = sStr;
                    }
                }
            } else {
                tanks[facing.ordinal()].amount = 0;
            }
        }

        CAN_BE_DRAINED = true;

        if (pushDir != null) {
            pushAll(pushDir);
        } else if (owner.connects(EnumFacing.DOWN)) {
            pushAll(EnumFacing.DOWN);
        } else {
            /* FluidStack baseStack = tanks[6].get();
            if (baseStack == null) {
                List<EnumFacing> dirs = new ArrayList<EnumFacing>(6);
                for (EnumFacing facing : EnumFacing.VALUES) {
                    dirs.add(facing);
                }
                Collections.shuffle(dirs);
                for (EnumFacing facing : dirs) {
                    if (tanks[facing.ordinal()].get() != null) {
                        baseStack = tanks[facing.ordinal()].get();
                        break;
                    }
                }
            }

            if (baseStack != null) {
                float amount = baseStack.amount;
                Set<Tank> tankSet = new HashSet<Tank>();

                for (int i = 0; i <= 6; i++) {
                    if (i == 6 || owner.connects(EnumFacing.getFront(i))) {
                        Tank tank = tanks[i];
                        if (tank.get() != null && tank.get().isFluidEqual(baseStack)) {
                            tankSet.add(tank);
                            amount += tank.get().amount;
                        } else if (tank.get() == null) {
                            tankSet.add(tank);
                        }
                    }
                }

                int tankCount = tankSet.size();

                if (amount > 0) {
                    for (Tank tank : tankSet) {
                        int amt = Math.round(amount / tankCount);
                        if (amt > 0) {
                            if (tank.stack != null && tank.stack.amount != amt) {
                                tank.stack.amount = amt;
                                tank.dirty = true;
                            } else if (tank.stack == null) {
                                tank.stack = baseStack.copy();
                                tank.stack.amount = amt;
                                tank.dirty = true;
                            }
                        } else {
                            if (tank.stack != null) {
                                tank.stack = null;
                                tank.dirty = true;
                            }
                        }
                        amount -= amt;
                        tankCount--;
                    }
                }

                if (amount > 0) {
                    ModCharsetLib.logger.warn(String.format("[PipeFluidContainer->equalize] Accidentally voided %.3f mB at %s!", amount, owner.getPos().toString()));
                }
            } */
        }

        CAN_BE_DRAINED = false;

        checkPacketUpdate();
    }

    void sendPacket(boolean ignoreDirty) {
        if (owner.getWorld() != null && !owner.getWorld().isRemote) {
            ModCharsetPipes.packet.sendToAllAround(new PacketFluidUpdate(owner, this, ignoreDirty), owner, ModCharsetPipes.PIPE_TESR_DISTANCE);
        }
    }

    private void checkPacketUpdate() {
        if (fluidDirty) {
            if (owner.getWorld() != null && !owner.getWorld().isRemote) {
                sendPacket(false);
            }
            return;
        }

        for (int i = 0; i <= 6; i++) {
            if (tanks[i].isDirty()) {
                if (owner.getWorld() != null && !owner.getWorld().isRemote) {
                    sendPacket(false);
                }
                return;
            }
        }
    }

    private void pushAll(EnumFacing pushDir) {
        FluidUtils.push(tanks[pushDir.ordinal()], getTankBlockNeighbor(owner.getPos(), pushDir), TANK_RATE);
        FluidUtils.push(tanks[6], tanks[pushDir.ordinal()], TANK_RATE);
        for (EnumFacing facing : EnumFacing.VALUES) {
            if (facing != pushDir && owner.connects(facing)) {
                FluidUtils.push(tanks[facing.ordinal()], tanks[6], TANK_RATE);
            }
        }
    }

    public IFluidHandler getTankBlockNeighbor(BlockPos pos, EnumFacing direction) {
        BlockPos p = pos.offset(direction);
        TileEntity tile = owner.getWorld().getTileEntity(p);
        return FluidUtils.getFluidHandler(tile, direction.getOpposite());
    }
}


text:
using System;
using System.Runtime.CompilerServices;

namespace Serenity
{
    [Imported, Serializable, PreserveMemberCase]
    public class SaveResponse : ServiceResponse
    {
        public object EntityId { get; set; }
    }
}