Upload folder using huggingface_hub

1e92f2d verified about 1 year ago

12.3 kB

import type {
  ServerResponse,
  OutgoingHttpHeaders,
  OutgoingHttpHeader,
  IncomingMessage,
  IncomingHttpHeaders,
} from 'http'
import type { Socket } from 'net'
import type { TLSSocket } from 'tls'

import Stream from 'stream'
import {
  fromNodeOutgoingHttpHeaders,
  toNodeOutgoingHttpHeaders,
} from '../web/utils'

interface MockedRequestOptions {
  url: string
  headers: IncomingHttpHeaders
  method: string
  readable?: Stream.Readable
  socket?: Socket | null
}

export class MockedRequest extends Stream.Readable implements IncomingMessage {
  public url: string
  public readonly statusCode?: number | undefined
  public readonly statusMessage?: string | undefined
  public readonly headers: IncomingHttpHeaders
  public readonly method: string

  // This is hardcoded for now, but can be updated to be configurable if needed.
  public readonly httpVersion = '1.0'
  public readonly httpVersionMajor = 1
  public readonly httpVersionMinor = 0

  private bodyReadable?: Stream.Readable

  // If we don't actually have a socket, we'll just use a mock one that
  // always returns false for the `encrypted` property and undefined for the
  // `remoteAddress` property.
  public socket: Socket = new Proxy<TLSSocket>({} as TLSSocket, {
    get: (_target, prop) => {
      if (prop !== 'encrypted' && prop !== 'remoteAddress') {
        throw new Error('Method not implemented')
      }

      if (prop === 'remoteAddress') return undefined
      // For this mock request, always ensure we just respond with the encrypted
      // set to false to ensure there's no odd leakages.
      return false
    },
  })

  constructor({
    url,
    headers,
    method,
    socket = null,
    readable,
  }: MockedRequestOptions) {
    super()

    this.url = url
    this.headers = headers
    this.method = method

    if (readable) {
      this.bodyReadable = readable
      this.bodyReadable.on('end', () => this.emit('end'))
      this.bodyReadable.on('close', () => this.emit('close'))
    }

    if (socket) {
      this.socket = socket
    }
  }

  public get headersDistinct(): NodeJS.Dict<string[]> {
    const headers: NodeJS.Dict<string[]> = {}
    for (const [key, value] of Object.entries(this.headers)) {
      if (!value) continue

      headers[key] = Array.isArray(value) ? value : [value]
    }

    return headers
  }

  public _read(size: number): void {
    if (this.bodyReadable) {
      return this.bodyReadable._read(size)
    } else {
      this.emit('end')
      this.emit('close')
    }
  }

  /**
   * The `connection` property is just an alias for the `socket` property.
   *
   * @deprecated — since v13.0.0 - Use socket instead.
   */
  public get connection(): Socket {
    return this.socket
  }

  // The following methods are not implemented as they are not used in the
  // Next.js codebase.

  public get aborted(): boolean {
    throw new Error('Method not implemented')
  }

  public get complete(): boolean {
    throw new Error('Method not implemented')
  }

  public get trailers(): NodeJS.Dict<string> {
    throw new Error('Method not implemented')
  }

  public get trailersDistinct(): NodeJS.Dict<string[]> {
    throw new Error('Method not implemented')
  }

  public get rawTrailers(): string[] {
    throw new Error('Method not implemented')
  }

  public get rawHeaders(): string[] {
    throw new Error('Method not implemented.')
  }

  public setTimeout(): this {
    throw new Error('Method not implemented.')
  }
}

export interface MockedResponseOptions {
  statusCode?: number
  socket?: Socket | null
  headers?: OutgoingHttpHeaders
  resWriter?: (chunk: Uint8Array | Buffer | string) => boolean
}

export class MockedResponse extends Stream.Writable implements ServerResponse {
  public statusCode: number
  public statusMessage: string = ''
  public finished = false
  public headersSent = false
  public readonly socket: Socket | null

  /**
   * A promise that resolves to `true` when the response has been streamed.
   *
   * @internal - used internally by Next.js
   */
  public readonly hasStreamed: Promise<boolean>

  /**
   * A list of buffers that have been written to the response.
   *
   * @internal - used internally by Next.js
   */
  public readonly buffers: Buffer[] = []

  /**
   * The headers object that contains the headers that were initialized on the
   * response and any that were added subsequently.
   *
   * @internal - used internally by Next.js
   */
  public readonly headers: Headers

  private resWriter: MockedResponseOptions['resWriter']

  public readonly headPromise: Promise<void>
  private headPromiseResolve?: () => void

  constructor(res: MockedResponseOptions = {}) {
    super()

    this.statusCode = res.statusCode ?? 200
    this.socket = res.socket ?? null
    this.headers = res.headers
      ? fromNodeOutgoingHttpHeaders(res.headers)
      : new Headers()

    this.headPromise = new Promise<void>((resolve) => {
      this.headPromiseResolve = resolve
    })

    // Attach listeners for the `finish`, `end`, and `error` events to the
    // `MockedResponse` instance.
    this.hasStreamed = new Promise<boolean>((resolve, reject) => {
      this.on('finish', () => resolve(true))
      this.on('end', () => resolve(true))
      this.on('error', (err) => reject(err))
    }).then((val) => {
      this.headPromiseResolve?.()
      return val
    })

    if (res.resWriter) {
      this.resWriter = res.resWriter
    }
  }

  public appendHeader(name: string, value: string | string[]): this {
    const values = Array.isArray(value) ? value : [value]
    for (const v of values) {
      this.headers.append(name, v)
    }

    return this
  }

  /**
   * Returns true if the response has been sent, false otherwise.
   *
   * @internal - used internally by Next.js
   */
  public get isSent() {
    return this.finished || this.headersSent
  }

  /**
   * The `connection` property is just an alias for the `socket` property.
   *
   * @deprecated — since v13.0.0 - Use socket instead.
   */
  public get connection(): Socket | null {
    return this.socket
  }

  public write(chunk: Uint8Array | Buffer | string) {
    if (this.resWriter) {
      return this.resWriter(chunk)
    }
    this.buffers.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk))

    return true
  }

  public end() {
    this.finished = true
    return super.end(...arguments)
  }

  /**
   * This method is a no-op because the `MockedResponse` instance is not
   * actually connected to a socket. This method is not specified on the
   * interface type for `ServerResponse` but is called by Node.js.
   *
   * @see https://github.com/nodejs/node/pull/7949
   */
  public _implicitHeader() {}

  public _write(
    chunk: Buffer | string,
    _encoding: string,
    callback: () => void
  ) {
    this.write(chunk)

    // According to Node.js documentation, the callback MUST be invoked to
    // signal that the write completed successfully. If this callback is not
    // invoked, the 'finish' event will not be emitted.
    //
    // https://nodejs.org/docs/latest-v16.x/api/stream.html#writable_writechunk-encoding-callback
    callback()
  }

  public writeHead(
    statusCode: number,
    statusMessage?: string | undefined,
    headers?: OutgoingHttpHeaders | OutgoingHttpHeader[] | undefined
  ): this
  public writeHead(
    statusCode: number,
    headers?: OutgoingHttpHeaders | OutgoingHttpHeader[] | undefined
  ): this
  public writeHead(
    statusCode: number,
    statusMessage?:
      | string
      | OutgoingHttpHeaders
      | OutgoingHttpHeader[]
      | undefined,
    headers?: OutgoingHttpHeaders | OutgoingHttpHeader[] | undefined
  ): this {
    if (!headers && typeof statusMessage !== 'string') {
      headers = statusMessage
    } else if (typeof statusMessage === 'string' && statusMessage.length > 0) {
      this.statusMessage = statusMessage
    }

    if (headers) {
      // When headers have been set with response.setHeader(), they will be
      // merged with any headers passed to response.writeHead(), with the
      // headers passed to response.writeHead() given precedence.
      //
      // https://nodejs.org/api/http.html#responsewriteheadstatuscode-statusmessage-headers
      //
      // For this reason, we need to only call `set` to ensure that this will
      // overwrite any existing headers.
      if (Array.isArray(headers)) {
        // headers may be an Array where the keys and values are in the same list.
        // It is not a list of tuples. So, the even-numbered offsets are key
        // values, and the odd-numbered offsets are the associated values. The
        // array is in the same format as request.rawHeaders.
        for (let i = 0; i < headers.length; i += 2) {
          // The header key is always a string according to the spec.
          this.setHeader(headers[i] as string, headers[i + 1])
        }
      } else {
        for (const [key, value] of Object.entries(headers)) {
          // Skip undefined values
          if (typeof value === 'undefined') continue

          this.setHeader(key, value)
        }
      }
    }

    this.statusCode = statusCode
    this.headersSent = true
    this.headPromiseResolve?.()

    return this
  }

  public hasHeader(name: string): boolean {
    return this.headers.has(name)
  }

  public getHeader(name: string): string | undefined {
    return this.headers.get(name) ?? undefined
  }

  public getHeaders(): OutgoingHttpHeaders {
    return toNodeOutgoingHttpHeaders(this.headers)
  }

  public getHeaderNames(): string[] {
    return Array.from(this.headers.keys())
  }

  public setHeader(name: string, value: OutgoingHttpHeader) {
    if (Array.isArray(value)) {
      // Because `set` here should override any existing values, we need to
      // delete the existing values before setting the new ones via `append`.
      this.headers.delete(name)

      for (const v of value) {
        this.headers.append(name, v)
      }
    } else if (typeof value === 'number') {
      this.headers.set(name, value.toString())
    } else {
      this.headers.set(name, value)
    }

    return this
  }

  public removeHeader(name: string): void {
    this.headers.delete(name)
  }

  public flushHeaders(): void {
    // This is a no-op because we don't actually have a socket to flush the
    // headers to.
  }

  // The following methods are not implemented as they are not used in the
  // Next.js codebase.

  public get strictContentLength(): boolean {
    throw new Error('Method not implemented.')
  }

  public writeEarlyHints() {
    throw new Error('Method not implemented.')
  }

  public get req(): IncomingMessage {
    throw new Error('Method not implemented.')
  }

  public assignSocket() {
    throw new Error('Method not implemented.')
  }

  public detachSocket(): void {
    throw new Error('Method not implemented.')
  }

  public writeContinue(): void {
    throw new Error('Method not implemented.')
  }

  public writeProcessing(): void {
    throw new Error('Method not implemented.')
  }

  public get upgrading(): boolean {
    throw new Error('Method not implemented.')
  }

  public get chunkedEncoding(): boolean {
    throw new Error('Method not implemented.')
  }

  public get shouldKeepAlive(): boolean {
    throw new Error('Method not implemented.')
  }

  public get useChunkedEncodingByDefault(): boolean {
    throw new Error('Method not implemented.')
  }

  public get sendDate(): boolean {
    throw new Error('Method not implemented.')
  }

  public setTimeout(): this {
    throw new Error('Method not implemented.')
  }

  public addTrailers(): void {
    throw new Error('Method not implemented.')
  }

  public setHeaders(): this {
    throw new Error('Method not implemented.')
  }
}

interface RequestResponseMockerOptions {
  url: string
  headers?: IncomingHttpHeaders
  method?: string
  bodyReadable?: Stream.Readable
  resWriter?: (chunk: Uint8Array | Buffer | string) => boolean
  socket?: Socket | null
}

export function createRequestResponseMocks({
  url,
  headers = {},
  method = 'GET',
  bodyReadable,
  resWriter,
  socket = null,
}: RequestResponseMockerOptions) {
  return {
    req: new MockedRequest({
      url,
      headers,
      method,
      socket,
      readable: bodyReadable,
    }),
    res: new MockedResponse({ socket, resWriter }),
  }
}

	import type {
	ServerResponse,
	OutgoingHttpHeaders,
	OutgoingHttpHeader,
	IncomingMessage,
	IncomingHttpHeaders,
	} from 'http'
	import type { Socket } from 'net'
	import type { TLSSocket } from 'tls'

	import Stream from 'stream'
	import {
	fromNodeOutgoingHttpHeaders,
	toNodeOutgoingHttpHeaders,
	} from '../web/utils'

	interface MockedRequestOptions {
	url: string
	headers: IncomingHttpHeaders
	method: string
	readable?: Stream.Readable
	socket?: Socket \| null
	}

	export class MockedRequest extends Stream.Readable implements IncomingMessage {
	public url: string
	public readonly statusCode?: number \| undefined
	public readonly statusMessage?: string \| undefined
	public readonly headers: IncomingHttpHeaders
	public readonly method: string

	// This is hardcoded for now, but can be updated to be configurable if needed.
	public readonly httpVersion = '1.0'
	public readonly httpVersionMajor = 1
	public readonly httpVersionMinor = 0

	private bodyReadable?: Stream.Readable

	// If we don't actually have a socket, we'll just use a mock one that
	// always returns false for the `encrypted` property and undefined for the
	// `remoteAddress` property.
	public socket: Socket = new Proxy<TLSSocket>({} as TLSSocket, {
	get: (_target, prop) => {
	if (prop !== 'encrypted' && prop !== 'remoteAddress') {
	throw new Error('Method not implemented')
	}

	if (prop === 'remoteAddress') return undefined
	// For this mock request, always ensure we just respond with the encrypted
	// set to false to ensure there's no odd leakages.
	return false
	},
	})

	constructor({
	url,
	headers,
	method,
	socket = null,
	readable,
	}: MockedRequestOptions) {
	super()

	this.url = url
	this.headers = headers
	this.method = method

	if (readable) {
	this.bodyReadable = readable
	this.bodyReadable.on('end', () => this.emit('end'))
	this.bodyReadable.on('close', () => this.emit('close'))
	}

	if (socket) {
	this.socket = socket
	}
	}

	public get headersDistinct(): NodeJS.Dict<string[]> {
	const headers: NodeJS.Dict<string[]> = {}
	for (const [key, value] of Object.entries(this.headers)) {
	if (!value) continue

	headers[key] = Array.isArray(value) ? value : [value]
	}

	return headers
	}

	public _read(size: number): void {
	if (this.bodyReadable) {
	return this.bodyReadable._read(size)
	} else {
	this.emit('end')
	this.emit('close')
	}
	}

	/**
	* The `connection` property is just an alias for the `socket` property.
	*
	* @deprecated — since v13.0.0 - Use socket instead.
	*/
	public get connection(): Socket {
	return this.socket
	}

	// The following methods are not implemented as they are not used in the
	// Next.js codebase.

	public get aborted(): boolean {
	throw new Error('Method not implemented')
	}

	public get complete(): boolean {
	throw new Error('Method not implemented')
	}

	public get trailers(): NodeJS.Dict<string> {
	throw new Error('Method not implemented')
	}

	public get trailersDistinct(): NodeJS.Dict<string[]> {
	throw new Error('Method not implemented')
	}

	public get rawTrailers(): string[] {
	throw new Error('Method not implemented')
	}

	public get rawHeaders(): string[] {
	throw new Error('Method not implemented.')
	}

	public setTimeout(): this {
	throw new Error('Method not implemented.')
	}
	}

	export interface MockedResponseOptions {
	statusCode?: number
	socket?: Socket \| null
	headers?: OutgoingHttpHeaders
	resWriter?: (chunk: Uint8Array \| Buffer \| string) => boolean
	}

	export class MockedResponse extends Stream.Writable implements ServerResponse {
	public statusCode: number
	public statusMessage: string = ''
	public finished = false
	public headersSent = false
	public readonly socket: Socket \| null

	/**
	* A promise that resolves to `true` when the response has been streamed.
	*
	* @internal - used internally by Next.js
	*/
	public readonly hasStreamed: Promise<boolean>

	/**
	* A list of buffers that have been written to the response.
	*
	* @internal - used internally by Next.js
	*/
	public readonly buffers: Buffer[] = []

	/**
	* The headers object that contains the headers that were initialized on the
	* response and any that were added subsequently.
	*
	* @internal - used internally by Next.js
	*/
	public readonly headers: Headers

	private resWriter: MockedResponseOptions['resWriter']

	public readonly headPromise: Promise<void>
	private headPromiseResolve?: () => void

	constructor(res: MockedResponseOptions = {}) {
	super()

	this.statusCode = res.statusCode ?? 200
	this.socket = res.socket ?? null
	this.headers = res.headers
	? fromNodeOutgoingHttpHeaders(res.headers)
	: new Headers()

	this.headPromise = new Promise<void>((resolve) => {
	this.headPromiseResolve = resolve
	})

	// Attach listeners for the `finish`, `end`, and `error` events to the
	// `MockedResponse` instance.
	this.hasStreamed = new Promise<boolean>((resolve, reject) => {
	this.on('finish', () => resolve(true))
	this.on('end', () => resolve(true))
	this.on('error', (err) => reject(err))
	}).then((val) => {
	this.headPromiseResolve?.()
	return val
	})

	if (res.resWriter) {
	this.resWriter = res.resWriter
	}
	}

	public appendHeader(name: string, value: string \| string[]): this {
	const values = Array.isArray(value) ? value : [value]
	for (const v of values) {
	this.headers.append(name, v)
	}

	return this
	}

	/**
	* Returns true if the response has been sent, false otherwise.
	*
	* @internal - used internally by Next.js
	*/
	public get isSent() {
	return this.finished \|\| this.headersSent
	}

	/**
	* The `connection` property is just an alias for the `socket` property.
	*
	* @deprecated — since v13.0.0 - Use socket instead.
	*/
	public get connection(): Socket \| null {
	return this.socket
	}

	public write(chunk: Uint8Array \| Buffer \| string) {
	if (this.resWriter) {
	return this.resWriter(chunk)
	}
	this.buffers.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk))

	return true
	}

	public end() {
	this.finished = true
	return super.end(...arguments)
	}

	/**
	* This method is a no-op because the `MockedResponse` instance is not
	* actually connected to a socket. This method is not specified on the
	* interface type for `ServerResponse` but is called by Node.js.
	*
	* @see https://github.com/nodejs/node/pull/7949
	*/
	public _implicitHeader() {}

	public _write(
	chunk: Buffer \| string,
	_encoding: string,
	callback: () => void
	) {
	this.write(chunk)

	// According to Node.js documentation, the callback MUST be invoked to
	// signal that the write completed successfully. If this callback is not
	// invoked, the 'finish' event will not be emitted.
	//
	// https://nodejs.org/docs/latest-v16.x/api/stream.html#writable_writechunk-encoding-callback
	callback()
	}

	public writeHead(
	statusCode: number,
	statusMessage?: string \| undefined,
	headers?: OutgoingHttpHeaders \| OutgoingHttpHeader[] \| undefined
	): this
	public writeHead(
	statusCode: number,
	headers?: OutgoingHttpHeaders \| OutgoingHttpHeader[] \| undefined
	): this
	public writeHead(
	statusCode: number,
	statusMessage?:
	\| string
	\| OutgoingHttpHeaders
	\| OutgoingHttpHeader[]
	\| undefined,
	headers?: OutgoingHttpHeaders \| OutgoingHttpHeader[] \| undefined
	): this {
	if (!headers && typeof statusMessage !== 'string') {
	headers = statusMessage
	} else if (typeof statusMessage === 'string' && statusMessage.length > 0) {
	this.statusMessage = statusMessage
	}

	if (headers) {
	// When headers have been set with response.setHeader(), they will be
	// merged with any headers passed to response.writeHead(), with the
	// headers passed to response.writeHead() given precedence.
	//
	// https://nodejs.org/api/http.html#responsewriteheadstatuscode-statusmessage-headers
	//
	// For this reason, we need to only call `set` to ensure that this will
	// overwrite any existing headers.
	if (Array.isArray(headers)) {
	// headers may be an Array where the keys and values are in the same list.
	// It is not a list of tuples. So, the even-numbered offsets are key
	// values, and the odd-numbered offsets are the associated values. The
	// array is in the same format as request.rawHeaders.
	for (let i = 0; i < headers.length; i += 2) {
	// The header key is always a string according to the spec.
	this.setHeader(headers[i] as string, headers[i + 1])
	}
	} else {
	for (const [key, value] of Object.entries(headers)) {
	// Skip undefined values
	if (typeof value === 'undefined') continue

	this.setHeader(key, value)
	}
	}
	}

	this.statusCode = statusCode
	this.headersSent = true
	this.headPromiseResolve?.()

	return this
	}

	public hasHeader(name: string): boolean {
	return this.headers.has(name)
	}

	public getHeader(name: string): string \| undefined {
	return this.headers.get(name) ?? undefined
	}

	public getHeaders(): OutgoingHttpHeaders {
	return toNodeOutgoingHttpHeaders(this.headers)
	}

	public getHeaderNames(): string[] {
	return Array.from(this.headers.keys())
	}

	public setHeader(name: string, value: OutgoingHttpHeader) {
	if (Array.isArray(value)) {
	// Because `set` here should override any existing values, we need to
	// delete the existing values before setting the new ones via `append`.
	this.headers.delete(name)

	for (const v of value) {
	this.headers.append(name, v)
	}
	} else if (typeof value === 'number') {
	this.headers.set(name, value.toString())
	} else {
	this.headers.set(name, value)
	}

	return this
	}

	public removeHeader(name: string): void {
	this.headers.delete(name)
	}

	public flushHeaders(): void {
	// This is a no-op because we don't actually have a socket to flush the
	// headers to.
	}

	// The following methods are not implemented as they are not used in the
	// Next.js codebase.

	public get strictContentLength(): boolean {
	throw new Error('Method not implemented.')
	}

	public writeEarlyHints() {
	throw new Error('Method not implemented.')
	}

	public get req(): IncomingMessage {
	throw new Error('Method not implemented.')
	}

	public assignSocket() {
	throw new Error('Method not implemented.')
	}

	public detachSocket(): void {
	throw new Error('Method not implemented.')
	}

	public writeContinue(): void {
	throw new Error('Method not implemented.')
	}

	public writeProcessing(): void {
	throw new Error('Method not implemented.')
	}

	public get upgrading(): boolean {
	throw new Error('Method not implemented.')
	}

	public get chunkedEncoding(): boolean {
	throw new Error('Method not implemented.')
	}

	public get shouldKeepAlive(): boolean {
	throw new Error('Method not implemented.')
	}

	public get useChunkedEncodingByDefault(): boolean {
	throw new Error('Method not implemented.')
	}

	public get sendDate(): boolean {
	throw new Error('Method not implemented.')
	}

	public setTimeout(): this {
	throw new Error('Method not implemented.')
	}

	public addTrailers(): void {
	throw new Error('Method not implemented.')
	}

	public setHeaders(): this {
	throw new Error('Method not implemented.')
	}
	}

	interface RequestResponseMockerOptions {
	url: string
	headers?: IncomingHttpHeaders
	method?: string
	bodyReadable?: Stream.Readable
	resWriter?: (chunk: Uint8Array \| Buffer \| string) => boolean
	socket?: Socket \| null
	}

	export function createRequestResponseMocks({
	url,
	headers = {},
	method = 'GET',
	bodyReadable,
	resWriter,
	socket = null,
	}: RequestResponseMockerOptions) {
	return {
	req: new MockedRequest({
	url,
	headers,
	method,
	socket,
	readable: bodyReadable,
	}),
	res: new MockedResponse({ socket, resWriter }),
	}
	}