}


    /**
     * 
     * @param uuid
     *            wrapped uuid
     */
    public UUID ( rpc.uuid_t uuid ) {
        this.time_low = uuid.time_low;
        this.time_mid = uuid.time_mid;
        this.time_hi_and_version = uuid.time_hi_and_version;
        this.clock_seq_hi_and_reserved = uuid.clock_seq_hi_and_reserved;
        this.clock_seq_low = uuid.clock_seq_low;
        this.node = new byte[6];

    public UUID(rpc.uuid_t uuid) {
        time_low = uuid.time_low;
        time_mid = uuid.time_mid;
        time_hi_and_version = uuid.time_hi_and_version;
        clock_seq_hi_and_reserved = uuid.clock_seq_hi_and_reserved;
        clock_seq_low = uuid.clock_seq_low;
        node = new byte[6];
        node[0] = uuid.node[0];
        node[1] = uuid.node[1];
        node[2] = uuid.node[2];

        public int type;
        public uuid_t uuid;

        public void encode(NdrBuffer _dst) throws NdrException {
            _dst.align(4);
            _dst.enc_ndr_long(type);
            _dst.enc_ndr_long(uuid.time_low);
            _dst.enc_ndr_short(uuid.time_mid);
            _dst.enc_ndr_short(uuid.time_hi_and_version);
            _dst.enc_ndr_small(uuid.clock_seq_hi_and_reserved);

        assert isinstance(asyncpg_uuid, uuid.UUID)
        assert type(asyncpg_uuid) is not uuid.UUID
        with pytest.raises(TypeError):
            vars(asyncpg_uuid)
        return {"fast_uuid": asyncpg_uuid}

    class SomeCustomClass(BaseModel):
        class Config:
            arbitrary_types_allowed = True
            json_encoders = {uuid.UUID: str}

        a_uuid: MyUuid

    val uuidTag1 = UUID.randomUUID()
    val uuidTag2 = UUID.randomUUID()
    val request =
      Request.Builder()
        .url("https://square.com")
        .tag(UUID::class.java, uuidTag1)
        .tag(UUID::class.java, uuidTag2)
        .build()
    assertThat(request.tag(UUID::class.java)).isSameAs(uuidTag2)
  }

  @Test
  fun multipleTags() {
    val uuidTag = UUID.randomUUID()

 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */

package jcifs.smb1.dcerpc;

public interface DcerpcConstants {

    public static final UUID DCERPC_UUID_SYNTAX_NDR = new UUID("8a885d04-1ceb-11c9-9fe8-08002b104860");

    public static final int DCERPC_FIRST_FRAG      = 0x01; /* First fragment */
    public static final int DCERPC_LAST_FRAG       = 0x02; /* Last fragment */

 */

package jcifs.dcerpc;


@SuppressWarnings ( "javadoc" )
public interface DcerpcConstants {

    public static final UUID DCERPC_UUID_SYNTAX_NDR = new UUID("8a885d04-1ceb-11c9-9fe8-08002b104860");

    public static final int DCERPC_FIRST_FRAG = 0x01; /* First fragment */
    public static final int DCERPC_LAST_FRAG = 0x02; /* Last fragment */

from datetime import datetime, time, timedelta
from typing import Union
from uuid import UUID

from fastapi import Body, FastAPI

app = FastAPI()


@app.put("/items/{item_id}")
async def read_items(
    item_id: UUID,
    start_datetime: datetime = Body(),
    end_datetime: datetime = Body(),
    process_after: timedelta = Body(),
    repeat_at: Union[time, None] = Body(default=None),
):

from datetime import datetime, time, timedelta
from typing import Union
from uuid import UUID

from fastapi import Body, FastAPI
from typing_extensions import Annotated

app = FastAPI()


@app.put("/items/{item_id}")
async def read_items(
    item_id: UUID,
    start_datetime: Annotated[datetime, Body()],
    end_datetime: Annotated[datetime, Body()],
    process_after: Annotated[timedelta, Body()],

// Size -  implement hash.Hash Size
func (u UUIDHash) Size() int {
	return len(u.uuid)
}

// BlockSize -  implement hash.Hash BlockSize
func (u UUIDHash) BlockSize() int {
	return md5.BlockSize
}

var _ hash.Hash = &UUIDHash{}

// NewUUIDHash - new UUIDHash
func NewUUIDHash(uuid []byte) *UUIDHash {
	return &UUIDHash{uuid: uuid}