Function override does not work in Solang

The function overriding is not working for the following contract:
/**
 *Submitted for verification at polygonscan.com on 2021-10-11
*/

// SPDX-License-Identifier: MIT

// Amended by HashLips
/**
    !Disclaimer!
    These contracts have been used to create tutorials,
    and was created for the purpose to teach people
    how to create smart contracts on the blockchain.
    please review this code on your own before using any of
    the following code for production.
    HashLips will not be liable in any way if for the use
    of the code. That being said, the code has been tested
    to the best of the developers' knowledge to work as intended.
*/

// File: @openzeppelin/contracts/utils/introspection/IERC165.sol
pragma solidity^0.8.0;
/**
 * @dev Interface of the ERC165 standard, as defined in the
 * https://eips.ethereum.org/EIPS/eip-165[EIP].
 *
 * Implementers can declare support of contract interfaces, which can then be
 * queried by others ({ERC165Checker}).
 *
 * For an implementation, see {ERC165}.
 */
interface IERC165 {
    /**
     * @dev Returns true if this contract implements the interface defined by
     * `interfaceId`. See the corresponding
     * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section]
     * to learn more about how these ids are created.
     *
     * This function call must use less than 30 000 gas.
     */
    function supportsInterface(bytes4 interfaceId) external view returns(bool);
}

// File: @openzeppelin/contracts/token/ERC721/IERC721.sol
pragma solidity^0.8.0;
/**
 * @dev Required interface of an ERC721 compliant contract.
 */
interface IERC721 is IERC165 {
    /**
     * @dev Emitted when `tokenId` token is transferred from `from` to `to`.
     */
    event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);

    /**
     * @dev Emitted when `owner` enables `approved` to manage the `tokenId` token.
     */
    event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);

    /**
     * @dev Emitted when `owner` enables or disables (`approved`) `operator` to manage all of its assets.
     */
    event ApprovalForAll(address indexed owner, address indexed operator, bool approved);

	/**
	 * @dev Returns the number of tokens in ``owner``'s account.
	 */
	function balanceOf(address owner) external view returns(uint256 balance);

	/**
	 * @dev Returns the owner of the `tokenId` token.
	 *
	 * Requirements:
	 *
	 * - `tokenId` must exist.
	 */
	function ownerOf(uint256 tokenId) external view returns(address owner);

	/**
	 * @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients
	 * are aware of the ERC721 protocol to prevent tokens from being forever locked.
	 *
	 * Requirements:
	 *
	 * - `from` cannot be the zero address.
	 * - `to` cannot be the zero address.
	 * - `tokenId` token must exist and be owned by `from`.
	 * - If the caller is not `from`, it must be have been allowed to move this token by either {approve} or {setApprovalForAll}.
	 * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
	 *
	 * Emits a {Transfer} event.
	 */
	function safeTransferFrom(
		address from,
		address to,
		uint256 tokenId
	) external;

	/**
	 * @dev Transfers `tokenId` token from `from` to `to`.
	 *
	 * WARNING: Usage of this method is discouraged, use {safeTransferFrom} whenever possible.
	 *
	 * Requirements:
	 *
	 * - `from` cannot be the zero address.
	 * - `to` cannot be the zero address.
	 * - `tokenId` token must be owned by `from`.
	 * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.
	 *
	 * Emits a {Transfer} event.
	 */
	function transferFrom(
		address from,
		address to,
		uint256 tokenId
	) external;

	/**
	 * @dev Gives permission to `to` to transfer `tokenId` token to another account.
	 * The approval is cleared when the token is transferred.
	 *
	 * Only a single account can be approved at a time, so approving the zero address clears previous approvals.
	 *
	 * Requirements:
	 *
	 * - The caller must own the token or be an approved operator.
	 * - `tokenId` must exist.
	 *
	 * Emits an {Approval} event.
	 */
	function approve(address to, uint256 tokenId) external;

	/**
	 * @dev Returns the account approved for `tokenId` token.
	 *
	 * Requirements:
	 *
	 * - `tokenId` must exist.
	 */
	function getApproved(uint256 tokenId) external view returns(address operator);

	/**
	 * @dev Approve or remove `operator` as an operator for the caller.
	 * Operators can call {transferFrom} or {safeTransferFrom} for any token owned by the caller.
	 *
	 * Requirements:
	 *
	 * - The `operator` cannot be the caller.
	 *
	 * Emits an {ApprovalForAll} event.
	 */
	function setApprovalForAll(address operator, bool _approved) external;

	/**
	 * @dev Returns if the `operator` is allowed to manage all of the assets of `owner`.
	 *
	 * See {setApprovalForAll}
	 */
	function isApprovedForAll(address owner, address operator) external view returns(bool);

	/**
	 * @dev Safely transfers `tokenId` token from `from` to `to`.
	 *
	 * Requirements:
	 *
	 * - `from` cannot be the zero address.
	 * - `to` cannot be the zero address.
	 * - `tokenId` token must exist and be owned by `from`.
	 * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.
	 * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
	 *
	 * Emits a {Transfer} event.
	 */
	function safeTransferFrom(
		address from,
		address to,
		uint256 tokenId,
		bytes calldata data
	) external;
}

// File: @openzeppelin/contracts/token/ERC721/extensions/IERC721Enumerable.sol
pragma solidity^0.8.0;
/**
 * @title ERC-721 Non-Fungible Token Standard, optional enumeration extension
 * @dev See https://eips.ethereum.org/EIPS/eip-721
 */
interface IERC721Enumerable is IERC721 {
	/**
	 * @dev Returns the total amount of tokens stored by the contract.
	 */
	function totalSupply() external view returns(uint256);

	/**
	 * @dev Returns a token ID owned by `owner` at a given `index` of its token list.
	 * Use along with {balanceOf} to enumerate all of ``owner``'s tokens.
	 */
	function tokenOfOwnerByIndex(address owner, uint256 index) external view returns(uint256 tokenId);

	/**
	 * @dev Returns a token ID at a given `index` of all the tokens stored by the contract.
	 * Use along with {totalSupply} to enumerate all tokens.
	 */
	function tokenByIndex(uint256 index) external view returns(uint256);
}

// File: @openzeppelin/contracts/utils/introspection/ERC165.sol
pragma solidity^0.8.0;
/**
 * @dev Implementation of the {IERC165} interface.
 *
 * Contracts that want to implement ERC165 should inherit from this contract and override {supportsInterface} to check
 * for the additional interface id that will be supported. For example:
 *
 * ```solidity
 * function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
 *     return interfaceId == type(MyInterface).interfaceId || super.supportsInterface(interfaceId);
 * }
 * ```
 *
 * Alternatively, {ERC165Storage} provides an easier to use but more expensive implementation.
 */
abstract contract ERC165 is IERC165 {
	/**
	 * @dev See {IERC165-supportsInterface}.
	 */
	function supportsInterface(bytes4 interfaceId) public view virtual override returns(bool) {
		return interfaceId==type(IERC165).interfaceId;
	}
}

// File: @openzeppelin/contracts/utils/Strings.sol

pragma solidity^0.8.0;

/**
 * @dev String operations.
 */
library Strings {
    bytes16 private constant _HEX_SYMBOLS="0123456789abcdef";

	/**
	 * @dev Converts a `uint256` to its ASCII `string` decimal representation.
	 */
	function toString(uint256 value) internal pure returns(string memory) {
		// Inspired by OraclizeAPI's implementation - MIT licence
		// https://github.com/oraclize/ethereum-api/blob/b42146b063c7d6ee1358846c198246239e9360e8/oraclizeAPI_0.4.25.sol

		if (value==0) {
			return "0";
		}
        uint256 temp=value;
        uint256 digits;
		while (temp!=0) {
			digits++;
			temp/=10;
		}
        bytes memory buffer=new bytes(digits);
		while (value!=0) {
			digits-=1;
			buffer[digits]=bytes1(uint8(48+uint256(value%10)));
			value/=10;
		}
		return string(buffer);
	}

	/**
	 * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation.
	 */
	function toHexString(uint256 value) internal pure returns(string memory) {
		if (value==0) {
			return "0x00";
		}
        uint256 temp=value;
        uint256 length=0;
		while (temp!=0) {
			length++;
			temp>>=8;
		}
		return toHexString(value, length);
	}

	/**
	 * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation with fixed length.
	 */
	function toHexString(uint256 value, uint256 length) internal pure returns(string memory) {
        bytes memory buffer=new bytes(2*length+2);
		buffer[0]="0";
		buffer[1]="x";
		for (uint256 i=2*length+1; i>1; --i) {
			buffer[i]=_HEX_SYMBOLS[value&0xf];
			value>>=4;
		}
		require(value==0, "Strings: hex length insufficient");
		return string(buffer);
	}
}

// File: @openzeppelin/contracts/utils/Address.sol

pragma solidity^0.8.0;

/**
 * @dev Collection of functions related to the address type
 */
library Address {
	/**
	 * @dev Returns true if `account` is a contract.
	 *
	 * [IMPORTANT]
	 * ====
	 * It is unsafe to assume that an address for which this function returns
	 * false is an externally-owned account (EOA) and not a contract.
	 *
	 * Among others, `isContract` will return false for the following
	 * types of addresses:
	 *
	 *  - an externally-owned account
	 *  - a contract in construction
	 *  - an address where a contract will be created
	 *  - an address where a contract lived, but was destroyed
	 * ====
	 */
	function isContract(address account) internal view returns(bool) {
        // This method relies on extcodesize, which returns 0 for contracts in
        // construction, since the code is only stored at the end of the
        // constructor execution.

        uint256 size;
        assembly {
			size:=extcodesize(account)
		}
		return size>0;
	}

	/**
	 * @dev Replacement for Solidity's `transfer`: sends `amount` wei to
	 * `recipient`, forwarding all available gas and reverting on errors.
	 *
	 * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost
	 * of certain opcodes, possibly making contracts go over the 2300 gas limit
	 * imposed by `transfer`, making them unable to receive funds via
	 * `transfer`. {sendValue} removes this limitation.
	 *
	 * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].
	 *
	 * IMPORTANT: because control is transferred to `recipient`, care must be
	 * taken to not create reentrancy vulnerabilities. Consider using
	 * {ReentrancyGuard} or the
	 * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].
	 */
	function sendValue(address payable recipient, uint256 amount) internal {
		require(address(this).balance>=amount, "Address: insufficient balance");

		(bool success, ) = recipient.call{ value: amount } ("");
		require(success, "Address: unable to send value, recipient may have reverted");
	}

	/**
	 * @dev Performs a Solidity function call using a low level `call`. A
	 * plain `call` is an unsafe replacement for a function call: use this
	 * function instead.
	 *
	 * If `target` reverts with a revert reason, it is bubbled up by this
	 * function (like regular Solidity function calls).
	 *
	 * Returns the raw returned data. To convert to the expected return value,
	 * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].
	 *
	 * Requirements:
	 *
	 * - `target` must be a contract.
	 * - calling `target` with `data` must not revert.
	 *
	 * _Available since v3.1._
	 */
	function functionCall(address target, bytes memory data) internal returns(bytes memory) {
		return functionCall(target, data, "Address: low-level call failed");
	}

	/**
	 * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with
	 * `errorMessage` as a fallback revert reason when `target` reverts.
	 *
	 * _Available since v3.1._
	 */
	function functionCall(
		address target,
		bytes memory data,
		string memory errorMessage
	) internal returns(bytes memory) {
		return functionCallWithValue(target, data, 0, errorMessage);
	}

	/**
	 * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
	 * but also transferring `value` wei to `target`.
	 *
	 * Requirements:
	 *
	 * - the calling contract must have an ETH balance of at least `value`.
	 * - the called Solidity function must be `payable`.
	 *
	 * _Available since v3.1._
	 */
	function functionCallWithValue(
		address target,
		bytes memory data,
		uint256 value
	) internal returns(bytes memory) {
		return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
	}

	/**
	 * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but
	 * with `errorMessage` as a fallback revert reason when `target` reverts.
	 *
	 * _Available since v3.1._
	 */
	function functionCallWithValue(
		address target,
		bytes memory data,
		uint256 value,
		string memory errorMessage
	) internal returns(bytes memory) {
		require(address(this).balance>=value, "Address: insufficient balance for call");
		require(isContract(target), "Address: call to non-contract");

		(bool success, bytes memory returndata) = target.call{ value: value } (data);
		return verifyCallResult(success, returndata, errorMessage);
	}

	/**
	 * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
	 * but performing a static call.
	 *
	 * _Available since v3.3._
	 */
	function functionStaticCall(address target, bytes memory data) internal view returns(bytes memory) {
		return functionStaticCall(target, data, "Address: low-level static call failed");
	}

	/**
	 * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
	 * but performing a static call.
	 *
	 * _Available since v3.3._
	 */
	function functionStaticCall(
		address target,
		bytes memory data,
		string memory errorMessage
	) internal view returns(bytes memory) {
		require(isContract(target), "Address: static call to non-contract");

		(bool success, bytes memory returndata) = target.staticcall(data);
		return verifyCallResult(success, returndata, errorMessage);
	}

	/**
	 * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
	 * but performing a delegate call.
	 *
	 * _Available since v3.4._
	 */
	function functionDelegateCall(address target, bytes memory data) internal returns(bytes memory) {
		return functionDelegateCall(target, data, "Address: low-level delegate call failed");
	}

	/**
	 * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
	 * but performing a delegate call.
	 *
	 * _Available since v3.4._
	 */
	function functionDelegateCall(
		address target,
		bytes memory data,
		string memory errorMessage
	) internal returns(bytes memory) {
		require(isContract(target), "Address: delegate call to non-contract");

		(bool success, bytes memory returndata) = target.delegatecall(data);
		return verifyCallResult(success, returndata, errorMessage);
	}

	/**
	 * @dev Tool to verifies that a low level call was successful, and revert if it wasn't, either by bubbling the
	 * revert reason using the provided one.
	 *
	 * _Available since v4.3._
	 */
	function verifyCallResult(
		bool success,
		bytes memory returndata,
		string memory errorMessage
	) internal pure returns(bytes memory) {
		if (success) {
			return returndata;
		} else {
			// Look for revert reason and bubble it up if present
			if (returndata.length>0) {
                // The easiest way to bubble the revert reason is using memory via assembly

                assembly {
					let returndata_size:=mload(returndata)
					revert(add(32, returndata), returndata_size)
				}
			} else {
				revert(errorMessage);
			}
		}
	}
}

// File: @openzeppelin/contracts/token/ERC721/extensions/IERC721Metadata.sol

pragma solidity^0.8.0;

/**
 * @title ERC-721 Non-Fungible Token Standard, optional metadata extension
 * @dev See https://eips.ethereum.org/EIPS/eip-721
 */
interface IERC721Metadata is IERC721 {
	/**
	 * @dev Returns the token collection name.
	 */
	function name() external view returns(string memory);

	/**
	 * @dev Returns the token collection symbol.
	 */
	function symbol() external view returns(string memory);

	/**
	 * @dev Returns the Uniform Resource Identifier (URI) for `tokenId` token.
	 */
	function tokenURI(uint256 tokenId) external view returns(string memory);
}

// File: @openzeppelin/contracts/token/ERC721/IERC721Receiver.sol

pragma solidity^0.8.0;

/**
 * @title ERC721 token receiver interface
 * @dev Interface for any contract that wants to support safeTransfers
 * from ERC721 asset contracts.
 */
interface IERC721Receiver {
    /**
     * @dev Whenever an {IERC721} `tokenId` token is transferred to this contract via {IERC721-safeTransferFrom}
     * by `operator` from `from`, this function is called.
     *
     * It must return its Solidity selector to confirm the token transfer.
     * If any other value is returned or the interface is not implemented by the recipient, the transfer will be reverted.
     *
     * The selector can be obtained in Solidity with `IERC721.onERC721Received.selector`.
     */
    function onERC721Received(
	address operator,
	address from,
	uint256 tokenId,
	bytes calldata data
) external returns(bytes4);
}

// File: @openzeppelin/contracts/utils/Context.sol
pragma solidity^0.8.0;
/**
 * @dev Provides information about the current execution context, including the
 * sender of the transaction and its data. While these are generally available
 * via msg.sender and msg.data, they should not be accessed in such a direct
 * manner, since when dealing with meta-transactions the account sending and
 * paying for execution may not be the actual sender (as far as an application
 * is concerned).
 *
 * This contract is only required for intermediate, library-like contracts.
 */
abstract contract Context {
	function _msgSender() internal view virtual returns(address) {
		return msg.sender;
	}

	function _msgData() internal view virtual returns(bytes calldata) {
		return msg.data;
	}
}

// File: @openzeppelin/contracts/token/ERC721/ERC721.sol
pragma solidity^0.8.0;
/**
 * @dev Implementation of https://eips.ethereum.org/EIPS/eip-721[ERC721] Non-Fungible Token Standard, including
 * the Metadata extension, but not including the Enumerable extension, which is available separately as
 * {ERC721Enumerable}.
 */
contract ERC721 is Context, ERC165, IERC721, IERC721Metadata {
    using Address for address;
		using Strings for uint256;

			// Token name
			string private _name;

    // Token symbol
    string private _symbol;

	// Mapping from token ID to owner address
	mapping(uint256 => address) private _owners;

	// Mapping owner address to token count
	mapping(address => uint256) private _balances;

	// Mapping from token ID to approved address
	mapping(uint256 => address) private _tokenApprovals;

	// Mapping from owner to operator approvals
	mapping(address => mapping(address => bool)) private _operatorApprovals;

	/**
	 * @dev Initializes the contract by setting a `name` and a `symbol` to the token collection.
	 */
	constructor(string memory name_, string memory symbol_) {
		_name=name_;
		_symbol=symbol_;
	}

	/**
	 * @dev See {IERC165-supportsInterface}.
	 */
	function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165, IERC165) returns(bool) {
		return
		interfaceId==type(IERC721).interfaceId||
			interfaceId==type(IERC721Metadata).interfaceId||
			super.supportsInterface(interfaceId);
	}

	/**
	 * @dev See {IERC721-balanceOf}.
	 */
	function balanceOf(address owner) public view virtual override returns(uint256) {
		require(owner!=address(0), "ERC721: balance query for the zero address");
		return _balances[owner];
	}

	/**
	 * @dev See {IERC721-ownerOf}.
	 */
	function ownerOf(uint256 tokenId) public view virtual override returns(address) {
        address owner=_owners[tokenId];
		require(owner!=address(0), "ERC721: owner query for nonexistent token");
		return owner;
	}

	/**
	 * @dev See {IERC721Metadata-name}.
	 */
	function name() public view virtual override returns(string memory) {
		return _name;
	}

	/**
	 * @dev See {IERC721Metadata-symbol}.
	 */
	function symbol() public view virtual override returns(string memory) {
		return _symbol;
	}

	/**
	 * @dev See {IERC721Metadata-tokenURI}.
	 */
	function tokenURI(uint256 tokenId) public view virtual override returns(string memory) {
		require(_exists(tokenId), "ERC721Metadata: URI query for nonexistent token");

        string memory baseURI=_baseURI();
		return bytes(baseURI).length>0? string(abi.encodePacked(baseURI, tokenId.toString())):"";
	}

	/**
	 * @dev Base URI for computing {tokenURI}. If set, the resulting URI for each
	 * token will be the concatenation of the `baseURI` and the `tokenId`. Empty
	 * by default, can be overriden in child contracts.
	 */
	function _baseURI() internal view virtual returns(string memory) {
		return "";
	}

	/**
	 * @dev See {IERC721-approve}.
	 */
	function approve(address to, uint256 tokenId) public virtual override {
        address owner=ERC721.ownerOf(tokenId);
		require(to!=owner, "ERC721: approval to current owner");

		require(
			_msgSender()==owner||isApprovedForAll(owner, _msgSender()),
			"ERC721: approve caller is not owner nor approved for all"
		);

		_approve(to, tokenId);
	}

	/**
	 * @dev See {IERC721-getApproved}.
	 */
	function getApproved(uint256 tokenId) public view virtual override returns(address) {
		require(_exists(tokenId), "ERC721: approved query for nonexistent token");

		return _tokenApprovals[tokenId];
	}

	/**
	 * @dev See {IERC721-setApprovalForAll}.
	 */
	function setApprovalForAll(address operator, bool approved) public virtual override {
		require(operator!=_msgSender(), "ERC721: approve to caller");

		_operatorApprovals[_msgSender()][operator]=approved;
        emit ApprovalForAll(_msgSender(), operator, approved);
	}

	/**
	 * @dev See {IERC721-isApprovedForAll}.
	 */
	function isApprovedForAll(address owner, address operator) public view virtual override returns(bool) {
		return _operatorApprovals[owner][operator];
	}

	/**
	 * @dev See {IERC721-transferFrom}.
	 */
	function transferFrom(
		address from,
		address to,
		uint256 tokenId
	) public virtual override {
		//solhint-disable-next-line max-line-length
		require(_isApprovedOrOwner(_msgSender(), tokenId), "ERC721: transfer caller is not owner nor approved");

		_transfer(from, to, tokenId);
	}

	/**
	 * @dev See {IERC721-safeTransferFrom}.
	 */
	function safeTransferFrom(
		address from,
		address to,
		uint256 tokenId
	) public virtual override {
		safeTransferFrom(from, to, tokenId, "");
	}

	/**
	 * @dev See {IERC721-safeTransferFrom}.
	 */
	function safeTransferFrom(
		address from,
		address to,
		uint256 tokenId,
		bytes memory _data
	) public virtual override {
		require(_isApprovedOrOwner(_msgSender(), tokenId), "ERC721: transfer caller is not owner nor approved");
		_safeTransfer(from, to, tokenId, _data);
	}

	/**
	 * @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients
	 * are aware of the ERC721 protocol to prevent tokens from being forever locked.
	 *
	 * `_data` is additional data, it has no specified format and it is sent in call to `to`.
	 *
	 * This internal function is equivalent to {safeTransferFrom}, and can be used to e.g.
	 * implement alternative mechanisms to perform token transfer, such as signature-based.
	 *
	 * Requirements:
	 *
	 * - `from` cannot be the zero address.
	 * - `to` cannot be the zero address.
	 * - `tokenId` token must exist and be owned by `from`.
	 * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
	 *
	 * Emits a {Transfer} event.
	 */
	function _safeTransfer(
		address from,
		address to,
		uint256 tokenId,
		bytes memory _data
	) internal virtual {
		_transfer(from, to, tokenId);
		require(_checkOnERC721Received(from, to, tokenId, _data), "ERC721: transfer to non ERC721Receiver implementer");
	}

	/**
	 * @dev Returns whether `tokenId` exists.
	 *
	 * Tokens can be managed by their owner or approved accounts via {approve} or {setApprovalForAll}.
	 *
	 * Tokens start existing when they are minted (`_mint`),
	 * and stop existing when they are burned (`_burn`).
	 */
	function _exists(uint256 tokenId) internal view virtual returns(bool) {
		return _owners[tokenId]!=address(0);
	}

	/**
	 * @dev Returns whether `spender` is allowed to manage `tokenId`.
	 *
	 * Requirements:
	 *
	 * - `tokenId` must exist.
	 */
	function _isApprovedOrOwner(address spender, uint256 tokenId) internal view virtual returns(bool) {
		require(_exists(tokenId), "ERC721: operator query for nonexistent token");
        address owner=ERC721.ownerOf(tokenId);
		return (spender==owner||getApproved(tokenId)==spender||isApprovedForAll(owner, spender));
	}

	/**
	 * @dev Safely mints `tokenId` and transfers it to `to`.
	 *
	 * Requirements:
	 *
	 * - `tokenId` must not exist.
	 * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
	 *
	 * Emits a {Transfer} event.
	 */
	function _safeMint(address to, uint256 tokenId) internal virtual {
		_safeMint(to, tokenId, "");
	}

	/**
	 * @dev Same as {xref-ERC721-_safeMint-address-uint256-}[`_safeMint`], with an additional `data` parameter which is
	 * forwarded in {IERC721Receiver-onERC721Received} to contract recipients.
	 */
	function _safeMint(
		address to,
		uint256 tokenId,
		bytes memory _data
	) internal virtual {
		_mint(to, tokenId);
		require(
			_checkOnERC721Received(address(0), to, tokenId, _data),
			"ERC721: transfer to non ERC721Receiver implementer"
		);
	}

	/**
	 * @dev Mints `tokenId` and transfers it to `to`.
	 *
	 * WARNING: Usage of this method is discouraged, use {_safeMint} whenever possible
	 *
	 * Requirements:
	 *
	 * - `tokenId` must not exist.
	 * - `to` cannot be the zero address.
	 *
	 * Emits a {Transfer} event.
	 */
	function _mint(address to, uint256 tokenId) internal virtual {
		require(to!=address(0), "ERC721: mint to the zero address");
		require(!_exists(tokenId), "ERC721: token already minted");

		_beforeTokenTransfer(address(0), to, tokenId);

		_balances[to]+=1;
		_owners[tokenId]=to;

        emit Transfer(address(0), to, tokenId);
	}

	/**
	 * @dev Destroys `tokenId`.
	 * The approval is cleared when the token is burned.
	 *
	 * Requirements:
	 *
	 * - `tokenId` must exist.
	 *
	 * Emits a {Transfer} event.
	 */
	function _burn(uint256 tokenId) internal virtual {
        address owner=ERC721.ownerOf(tokenId);

		_beforeTokenTransfer(owner, address(0), tokenId);

		// Clear approvals
		_approve(address(0), tokenId);

		_balances[owner]-=1;
		delete _owners[tokenId];

        emit Transfer(owner, address(0), tokenId);
	}

	/**
	 * @dev Transfers `tokenId` from `from` to `to`.
	 *  As opposed to {transferFrom}, this imposes no restrictions on msg.sender.
	 *
	 * Requirements:
	 *
	 * - `to` cannot be the zero address.
	 * - `tokenId` token must be owned by `from`.
	 *
	 * Emits a {Transfer} event.
	 */
	function _transfer(
		address from,
		address to,
		uint256 tokenId
	) internal virtual {
		require(ERC721.ownerOf(tokenId)==from, "ERC721: transfer of token that is not own");
		require(to!=address(0), "ERC721: transfer to the zero address");

		_beforeTokenTransfer(from, to, tokenId);

		// Clear approvals from the previous owner
		_approve(address(0), tokenId);

		_balances[from]-=1;
		_balances[to]+=1;
		_owners[tokenId]=to;

        emit Transfer(from, to, tokenId);
	}

	/**
	 * @dev Approve `to` to operate on `tokenId`
	 *
	 * Emits a {Approval} event.
	 */
	function _approve(address to, uint256 tokenId) internal virtual {
		_tokenApprovals[tokenId]=to;
        emit Approval(ERC721.ownerOf(tokenId), to, tokenId);
	}

	/**
	 * @dev Internal function to invoke {IERC721Receiver-onERC721Received} on a target address.
	 * The call is not executed if the target address is not a contract.
	 *
	 * @param from address representing the previous owner of the given token ID
	 * @param to target address that will receive the tokens
	 * @param tokenId uint256 ID of the token to be transferred
	 * @param _data bytes optional data to send along with the call
	 * @return bool whether the call correctly returned the expected magic value
	 */
	function _checkOnERC721Received(
		address from,
		address to,
		uint256 tokenId,
		bytes memory _data
	) private returns(bool) {
		if (to.isContract()) {
			try IERC721Receiver(to).onERC721Received(_msgSender(), from, tokenId, _data) returns(bytes4 retval) {
				return retval==IERC721Receiver.onERC721Received.selector;
			} catch (bytes memory reason) {
				if (reason.length==0) {
					revert("ERC721: transfer to non ERC721Receiver implementer");
				} else {
                    assembly {
						revert(add(32, reason), mload(reason))
					}
				}
			}
		} else {
			return true;
		}
	}

	/**
	 * @dev Hook that is called before any token transfer. This includes minting
	 * and burning.
	 *
	 * Calling conditions:
	 *
	 * - When `from` and `to` are both non-zero, ``from``'s `tokenId` will be
	 * transferred to `to`.
	 * - When `from` is zero, `tokenId` will be minted for `to`.
	 * - When `to` is zero, ``from``'s `tokenId` will be burned.
	 * - `from` and `to` are never both zero.
	 *
	 * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
	 */
	function _beforeTokenTransfer(
		address from,
		address to,
		uint256 tokenId
	) internal virtual { }
}

// File: @openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol

pragma solidity^0.8.0;

/**
 * @dev This implements an optional extension of {ERC721} defined in the EIP that adds
 * enumerability of all the token ids in the contract as well as all token ids owned by each
 * account.
 */
abstract contract ERC721Enumerable is ERC721, IERC721Enumerable {
	// Mapping from owner to list of owned token IDs
	mapping(address => mapping(uint256 => uint256)) private _ownedTokens;

	// Mapping from token ID to index of the owner tokens list
	mapping(uint256 => uint256) private _ownedTokensIndex;

	// Array with all token ids, used for enumeration
	uint256[] private _allTokens;

	// Mapping from token id to position in the allTokens array
	mapping(uint256 => uint256) private _allTokensIndex;

	/**
	 * @dev See {IERC165-supportsInterface}.
	 */
	function supportsInterface(bytes4 interfaceId) public view virtual override(IERC165, ERC721) returns(bool) {
		return interfaceId==type(IERC721Enumerable).interfaceId||super.supportsInterface(interfaceId);
	}

	/**
	 * @dev See {IERC721Enumerable-tokenOfOwnerByIndex}.
	 */
	function tokenOfOwnerByIndex(address owner, uint256 index) public view virtual override returns(uint256) {
		require(index<ERC721.balanceOf(owner), "ERC721Enumerable: owner index out of bounds");
		return _ownedTokens[owner][index];
	}

	/**
	 * @dev See {IERC721Enumerable-totalSupply}.
	 */
	function totalSupply() public view virtual override returns(uint256) {
		return _allTokens.length;
	}

	/**
	 * @dev See {IERC721Enumerable-tokenByIndex}.
	 */
	function tokenByIndex(uint256 index) public view virtual override returns(uint256) {
		require(index<ERC721Enumerable.totalSupply(), "ERC721Enumerable: global index out of bounds");
		return _allTokens[index];
	}

	/**
	 * @dev Hook that is called before any token transfer. This includes minting
	 * and burning.
	 *
	 * Calling conditions:
	 *
	 * - When `from` and `to` are both non-zero, ``from``'s `tokenId` will be
	 * transferred to `to`.
	 * - When `from` is zero, `tokenId` will be minted for `to`.
	 * - When `to` is zero, ``from``'s `tokenId` will be burned.
	 * - `from` cannot be the zero address.
	 * - `to` cannot be the zero address.
	 *
	 * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
	 */
	function _beforeTokenTransfer(
		address from,
		address to,
		uint256 tokenId
	) internal virtual override {
		super._beforeTokenTransfer(from, to, tokenId);

		if (from==address(0)) {
			_addTokenToAllTokensEnumeration(tokenId);
		} else if (from!=to) {
			_removeTokenFromOwnerEnumeration(from, tokenId);
		}
		if (to==address(0)) {
			_removeTokenFromAllTokensEnumeration(tokenId);
		} else if (to!=from) {
			_addTokenToOwnerEnumeration(to, tokenId);
		}
	}

	/**
	 * @dev Private function to add a token to this extension's ownership-tracking data structures.
	 * @param to address representing the new owner of the given token ID
	 * @param tokenId uint256 ID of the token to be added to the tokens list of the given address
	 */
	function _addTokenToOwnerEnumeration(address to, uint256 tokenId) private {
        uint256 length=ERC721.balanceOf(to);
		_ownedTokens[to][length]=tokenId;
		_ownedTokensIndex[tokenId]=length;
	}

	/**
	 * @dev Private function to add a token to this extension's token tracking data structures.
	 * @param tokenId uint256 ID of the token to be added to the tokens list
	 */
	function _addTokenToAllTokensEnumeration(uint256 tokenId) private {
		_allTokensIndex[tokenId]=_allTokens.length;
		_allTokens.push(tokenId);
	}

	/**
	 * @dev Private function to remove a token from this extension's ownership-tracking data structures. Note that
	 * while the token is not assigned a new owner, the `_ownedTokensIndex` mapping is _not_ updated: this allows for
	 * gas optimizations e.g. when performing a transfer operation (avoiding double writes).
	 * This has O(1) time complexity, but alters the order of the _ownedTokens array.
	 * @param from address representing the previous owner of the given token ID
	 * @param tokenId uint256 ID of the token to be removed from the tokens list of the given address
	 */
	function _removeTokenFromOwnerEnumeration(address from, uint256 tokenId) private {
        // To prevent a gap in from's tokens array, we store the last token in the index of the token to delete, and
        // then delete the last slot (swap and pop).

        uint256 lastTokenIndex=ERC721.balanceOf(from)-1;
        uint256 tokenIndex=_ownedTokensIndex[tokenId];

		// When the token to delete is the last token, the swap operation is unnecessary
		if (tokenIndex!=lastTokenIndex) {
            uint256 lastTokenId=_ownedTokens[from][lastTokenIndex];

			_ownedTokens[from][tokenIndex]=lastTokenId; // Move the last token to the slot of the to-delete token
			_ownedTokensIndex[lastTokenId]=tokenIndex; // Update the moved token's index
		}

		// This also deletes the contents at the last position of the array
		delete _ownedTokensIndex[tokenId];
		delete _ownedTokens[from][lastTokenIndex];
	}

	/**
	 * @dev Private function to remove a token from this extension's token tracking data structures.
	 * This has O(1) time complexity, but alters the order of the _allTokens array.
	 * @param tokenId uint256 ID of the token to be removed from the tokens list
	 */
	function _removeTokenFromAllTokensEnumeration(uint256 tokenId) private {
        // To prevent a gap in the tokens array, we store the last token in the index of the token to delete, and
        // then delete the last slot (swap and pop).

        uint256 lastTokenIndex=_allTokens.length-1;
        uint256 tokenIndex=_allTokensIndex[tokenId];

        // When the token to delete is the last token, the swap operation is unnecessary. However, since this occurs so
        // rarely (when the last minted token is burnt) that we still do the swap here to avoid the gas cost of adding
        // an 'if' statement (like in _removeTokenFromOwnerEnumeration)
        uint256 lastTokenId=_allTokens[lastTokenIndex];

		_allTokens[tokenIndex]=lastTokenId; // Move the last token to the slot of the to-delete token
		_allTokensIndex[lastTokenId]=tokenIndex; // Update the moved token's index

		// This also deletes the contents at the last position of the array
		delete _allTokensIndex[tokenId];
		_allTokens.pop();
	}
}

// File: @openzeppelin/contracts/access/Ownable.sol
pragma solidity^0.8.0;
/**
 * @dev Contract module which provides a basic access control mechanism, where
 * there is an account (an owner) that can be granted exclusive access to
 * specific functions.
 *
 * By default, the owner account will be the one that deploys the contract. This
 * can later be changed with {transferOwnership}.
 *
 * This module is used through inheritance. It will make available the modifier
 * `onlyOwner`, which can be applied to your functions to restrict their use to
 * the owner.
 */
abstract contract Ownable is Context {
    address private _owner;

    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);

	/**
	 * @dev Initializes the contract setting the deployer as the initial owner.
	 */
	constructor() {
		_setOwner(_msgSender());
	}

	/**
	 * @dev Returns the address of the current owner.
	 */
	function owner() public view virtual returns(address) {
		return _owner;
	}

    /**
     * @dev Throws if called by any account other than the owner.
     */
    modifier onlyOwner() {
		require(owner()==_msgSender(), "Ownable: caller is not the owner");
		_;
	}

	/**
	 * @dev Leaves the contract without owner. It will not be possible to call
	 * `onlyOwner` functions anymore. Can only be called by the current owner.
	 *
	 * NOTE: Renouncing ownership will leave the contract without an owner,
	 * thereby removing any functionality that is only available to the owner.
	 */
	function renounceOwnership() public virtual onlyOwner {
		_setOwner(address(0));
	}

	/**
	 * @dev Transfers ownership of the contract to a new account (`newOwner`).
	 * Can only be called by the current owner.
	 */
	function transferOwnership(address newOwner) public virtual onlyOwner {
		require(newOwner!=address(0), "Ownable: new owner is the zero address");
		_setOwner(newOwner);
	}

	function _setOwner(address newOwner) private {
        address oldOwner=_owner;
		_owner=newOwner;
        emit OwnershipTransferred(oldOwner, newOwner);
	}
}

pragma solidity>=0.7.0<0.9.0;

contract ZombieRobotsClubNFT is ERC721Enumerable, Ownable {
  using Strings for uint256;

		string baseURI;
  string public baseExtension=".json";
  uint256 public cost=5 ether;
  uint256 public maxSupply=10000;
  uint256 public maxMintAmount=20;
  bool public paused=false;
  bool public revealed=false;
  string public notRevealedUri;

	constructor(
		string memory _name,
		string memory _symbol,
		string memory _initBaseURI,
		string memory _initNotRevealedUri
	) ERC721(_name, _symbol) {
		setBaseURI(_initBaseURI);
		setNotRevealedURI(_initNotRevealedUri);
	}

	// internal
	function _baseURI() internal view virtual override returns(string memory) {
		return baseURI;
	}

	// public
	function mint(uint256 _mintAmount) public payable {
    uint256 supply=totalSupply();
		require(!paused);
		require(_mintAmount>0);
		require(_mintAmount<=maxMintAmount);
		require(supply+_mintAmount<=maxSupply);

		if (msg.sender!=owner()) {
			require(msg.value>=cost*_mintAmount);
		}

		for (uint256 i=1; i<=_mintAmount; i++) {
			_safeMint(msg.sender, supply+i);
		}
	}

	function walletOfOwner(address _owner)
	public
	view
	returns(uint256[] memory)
	{
    uint256 ownerTokenCount=balanceOf(_owner);
		uint256[] memory tokenIds=new uint256[](ownerTokenCount);
		for (uint256 i; i<ownerTokenCount; i++) {
			tokenIds[i]=tokenOfOwnerByIndex(_owner, i);
		}
		return tokenIds;
	}

	function tokenURI(uint256 tokenId)
	public
	view
	virtual
	override
	returns(string memory)
	{
		require(
			_exists(tokenId),
			"ERC721Metadata: URI query for nonexistent token"
		);

		if (revealed==false) {
			return notRevealedUri;
		}

    string memory currentBaseURI=_baseURI();
		return bytes(currentBaseURI).length>0
			? string(abi.encodePacked(currentBaseURI, tokenId.toString(), baseExtension))
			:"";
	}

	//only owner
	function reveal() public onlyOwner() {
		revealed=true;
	}

	function setCost(uint256 _newCost) public onlyOwner() {
		cost=_newCost;
	}

	function setmaxMintAmount(uint256 _newmaxMintAmount) public onlyOwner() {
		maxMintAmount=_newmaxMintAmount;
	}

	function setNotRevealedURI(string memory _notRevealedURI) public onlyOwner {
		notRevealedUri=_notRevealedURI;
	}

	function setBaseURI(string memory _newBaseURI) public onlyOwner {
		baseURI=_newBaseURI;
	}

	function setBaseExtension(string memory _newBaseExtension) public onlyOwner {
		baseExtension=_newBaseExtension;
	}

	function pause(bool _state) public onlyOwner {
		paused=_state;
	}

	function withdraw() public payable onlyOwner {
		(bool success, ) = payable(msg.sender).call{ value: address(this).balance } ("");
		require(success);
	}
}

The error is the following:
     ┌─ /home/lucas/Documents/solang/examples/test.sol:1033:69
     │
 229 │     function supportsInterface(bytes4 interfaceId) public view virtual override returns(bool) {
     │     ----------------------------------------------------------------------------------------- previous definition of function 'supportsInterface'
     ·
1033 │     function supportsInterface(bytes4 interfaceId) public view virtual override(IERC165, ERC721) returns(bool) {
     │                                                                        ^^^^^^^^^^^^^^^^^^^^^^^^^

error: function 'supportsInterface' override list does not contain 'ERC165'
     ┌─ /home/lucas/Documents/solang/examples/test.sol:1033:69
     │
 229 │     function supportsInterface(bytes4 interfaceId) public view virtual override returns(bool) {
     │     ----------------------------------------------------------------------------------------- previous definition of function 'supportsInterface'
     ·
1033 │     function supportsInterface(bytes4 interfaceId) public view virtual override(IERC165, ERC721) returns(bool) {
     │                                                                        ^^^^^^^^^^^^^^^^^^^^^^^^^

Maybe you will meet error soon  "error: conversion to bytes1 from uint256 not allowed".
Error code:
function _toString(uint i) internal pure returns (string memory c) {
    if (i == 0) return "0";
    uint j = i;
    uint length;
    while (j != 0) {
        length++;
        j /= 10;
    }
    bytes memory str = new bytes(length);
    uint k = length - 1;
    while (i != 0) {
        str[k--] = byte(48 + i % 10);
        i /= 10;
    }
    c = string(str);
}

Maybe you will meet error soon "error: conversion to bytes1 from uint256 not allowed". Error code:
function _toString(uint i) internal pure returns (string memory c) {
    if (i == 0) return "0";
    uint j = i;
    uint length;
    while (j != 0) {
        length++;
        j /= 10;
    }
    bytes memory str = new bytes(length);
    uint k = length - 1;
    while (i != 0) {
        str[k--] = byte(48 + i % 10);
        i /= 10;
    }
    c = string(str);
}

Error line

str[k--] = byte(48 + i % 10);

You have declared i as uint, which means it is a 256-bit integer. When you do 48 + i % 10, the compiler will cast all numbers to the widest integer available to avoid truncating the response, so the result will be a 256-bit integer too.
256 bits are 32 bytes, so there is no way to convert 32 bytes into 1 bytes without losing information. This is what the error means. If you are sure there is no problem truncating your result to one byte, just do str[k--] = uint8(48 + i % 10).
In addition, you function will still not compile because the variable length is undefined. You have not assigned a value to it before using it.

也许您很快就会遇到错误“错误：不允许从 uint256 转换为 bytes1”。错误代码：
function _toString(uint i) internal pure returns (string memory c) {
    if (i == 0) return "0";
    uint j = i;
    uint length;
    while (j != 0) {
        length++;
        j /= 10;
    }
    bytes memory str = new bytes(length);
    uint k = length - 1;
    while (i != 0) {
        str[k--] = byte(48 + i % 10);
        i /= 10;
    }
    c = string(str);
}

错误线

str[k--] = 字节（48 + i % 10）；

您已声明i为uint，这意味着它是一个 256 位整数。当您这样做48 + i % 10时，编译器会将所有数字转换为可用的最宽整数以避免截断响应，因此结果也将是 256 位整数。
256位就是32个字节，没有办法将32个字节转换成1个字节而不丢失信息。这就是错误的意思。如果您确定将结果截断为一个字节没有问题，只需执行str[k--] = uint8(48 + i % 10).
此外，您的函数仍然无法编译，因为变量length未定义。在使用它之前，您还没有为其赋值。

Maybe you will meet error soon "error: conversion to bytes1 from uint256 not allowed". Error code:
function _toString(uint i) internal pure returns (string memory c) {
    if (i == 0) return "0";
    uint j = i;
    uint length;
    while (j != 0) {
        length++;
        j /= 10;
    }
    bytes memory str = new bytes(length);
    uint k = length - 1;
    while (i != 0) {
        str[k--] = byte(48 + i % 10);
        i /= 10;
    }
    c = string(str);
}

Error line

str[k--] = byte(48 + i % 10);

You have declared i as uint, which means it is a 256-bit integer. When you do 48 + i % 10, the compiler will cast all numbers to the widest integer available to avoid truncating the response, so the result will be a 256-bit integer too.
256 bits are 32 bytes, and there is no way to convert 32 bytes into 1 bytes without losing information. This is what the error means. If you are sure there is no problem truncating your result to one byte, just do str[k--] = uint8(48 + i % 10).
In addition, you function will still not compile because the variable length is undefined. You have not assigned a value to it before using it.

It passed when i convert byte to uint8 and set length equal 100.But new problem coming in remix.ethereum.org.
Code:
// SPDX-License-Identifier: GPL-3.0

pragma solidity >=0.7.0 <0.9.0;

contract Test{
    function _toString(uint i) public pure returns (string memory c) {
        if (i == 0) return "0";
        uint j = i;
        uint length = 100;
        while (j != 0) {
            j /= 10;
        }
        bytes memory str = new bytes(length);
        uint k = length - 1;
        while (i != 0) {
            str[k--] = uint8(48 + i % 10);
            i /= 10;
        }
        c = string(str);
    }
}

Error:
  TypeError: Type uint8 is not implicitly convertible to expected type bytes1.
  --> contracts/Test.sol:17:24:

  17 | str[k--] = uint8(48 + i % 10);
    ^^^^^^^^^^^^^^^^^^

The contract you pasted works fine with Solang. I've tested that. remix.ethereum.org utilizes the Solc Ethereum compiler, which works quite differently from Solang. This is the reason for the error!
If your goal is to make the contract work with solc, then just exchange that line for str[k--] = bytes1(uint8(48 + i % 10)).

It worked when i add bytes1 convert to  uint8.
Thanks~


Update view-service-health.md

Added the updated URL for Service health page
Fixes https://github.com/MicrosoftDocs/microsoft-365-docs/issues/12813

@JohanFreelancer9 Please copy review

@temanteleary Please merge this PR. Thanks

@tiburd Please merge this PR. Thanks


Monaco: JS error in PF 12

Describe the bug
Forum Post: https://forum.primefaces.org/viewtopic.php?f=14&t=77299&
Go to Showcase: https://www.primefaces.org/showcase-ext/sections/monacoEditor/basicUsage.jsf

cc @blutorange
PrimeFaces Extensions version
12.0.0
JSF implementation
All
JSF version
2.3
Browser(s)
ALL

I have a feeling it was the updated from Monaco 0.33 to 0.34 that might have broken it?

We overwrite<EMAIL_ADDRESS>the file nls.js to support dynamic locales. This file has changed quite a bit since version 0.33, our overwrite is now missing functions.

Should I roll back to 0.33 for now?

I can take a look a closer this during the weekend. So unless you want to release a fixed version in the next few days, I don't think you need to.

ok cool you rock!


Get a random collection of text chunks

To switch https://github.com/dglazkov/wanderer to rely on polymath, it needs a way to query a random set of text chunks, to reproduce this functionality here:
https://github.com/dglazkov/wanderer/blob/main/ask_embeddings.py#L119

Thinking maybe the endpoint API needs to have several modes:

get a few most recent entries
get basic info only (model, chunks, size, etc.)
get a few entries from a certain date range (maybe before/after?)
get random sampling of the entries
get most similar entries given a vector (what's currently supported)
get all entries (basically, give me the whole thing)

Also, API should always try to return data in the library format -- right?

@jkomoros penny for your thoughts

Yeah I was thinking about this yesterday too. I think that the data should always be returned in the library format (or a subset of it) just for simplicity about format versioning.
The date filtering use case above implies that the info property needs to also grow a timestamp field (how should it be formatted?)
If we use the library format then we'd also need a query_similiarity on each chunk that is usually omitted but required when responding to a similarity query.
We'd also need a way to define that certain properties can be omitted in certain cases. For example for a similarity_query mode embedding can/should be dropped because the embeddings are large. And timestamp should almost always be dropped (it's only useful for date restrict queries)

Playing around with how to represent the use cases. POSTs can have the following arguments:
count: An integer representing the number of items (token or chunk, depending on 'count_type') to retrieve. Defaults to 10 if not provided. A negative number means 'all'
count_type: {'token', 'chunk'} Defaults to 'chunk'. If 'token', then we will return a number of chunks up to but not exceeding the count number of tokens.
query: a base64-encoded embedding of the query. May be omitted.
query_embedding_model: defaults to 'text-embedding-ada-002'
filter_before: filters out chunks whose timestamp is before this date. Optional.
filter_after: filters out chunks whose timestamp is after this date. Optional.
exclude: A comma-separated list of the following keys. Any key that is included will be omitted from chunks. Defaults to 'embedding'.
  - '*' - Exclude all info from chunks, which means chunks will be totally empty, however `chunk_count` in library will be set with how many chunks would have been returned.
  - '' - If the value is fully empty, then all content is included.
  - 'embedding' - The embedding field is omitted
  - 'info' - The info field is omitted
sort:
  - 'similarity' - (default) sorted by descending similarity to query. If no query is provided, order may be any order.
  - 'any' - No particular order.
  - 'random' - A random sort seeded by `seed`
  - 'timestamp' - Descending ordered by timestamp
sort_reversed: '1' if the sort should be ascending instead of descending.
seed: A string to seed the random sort in order to get deterministic results. If not provided, defaults to Date.now()

Are we building a query language 😆 ?

Maybe?
Two more thoughts:

do I have the semantics of filter_before and filter_after backwards? E.g. imagining in the future that we'd add e.g. filter_url that only includes chunks whose info.url matches a URL pattern. But the way I wrote the before/after filtering semantics above, it's filtering OUT things before or after the given date.
Should query actually be query_embedding? In the future it might be some cases where the raw text of the query is included, the embedding is calculated on the host (that would allow a library with a different embedding_model to interoperate seamlessly, at the cost of pushing API usage to the hosts and opening up a line of DOS style attacks to exhaust their API key). If we do that, the most obvious key for the query is just query.

OK, updating based on above:
count: An integer representing the max number of items (token or chunk, depending on 'count_type') to retrieve. Defaults to 10 if not provided. A negative number means 'all'. The endpoint might return fewer than this count.
count_type: {'token', 'chunk'} Defaults to 'chunk'. If 'token', then we will return a number of chunks up to but not exceeding the count number of tokens.
query_embedding: a base64-encoded embedding of the query. May be omitted. If provided, each chunk returned will also include a 'similarity' property, a float representing the similarity to the query.
query_embedding_model: The embedding type used for `query_embedding`. Defaults to 'text-embedding-ada-002'
filter_before: includes chunks whose timestamp is after this date, in ISO 8601 format. Optional.
filter_after: includes chunks whose timestamp is before this date, in ISO 8601 format. Optional.
omit: A comma-separated list of the following keys. Any key that is included will be omitted from chunks. Defaults to 'embedding'.
  - '*' - Exclude all info from chunks, which means the entire chunks dict will be totally empty, however `chunk_count` in library will be set with how many chunks would have been returned.
  - '' - If the value is fully empty, then all content is included.
  - 'embedding' - The embedding field is omitted
  - 'info' - The info field is omitted
sort:
  - 'similarity' - (default) sorted by descending similarity to query. If no query is provided, it's equivalent to 'any'.
  - 'any' - No particular order.
  - 'random' - A random sort seeded by `seed`
  - 'timestamp' - Descending ordered by timestamp
sort_reversed: '1' if the sort should be ascending instead of descending.
seed: A string to seed the random sort in order to get deterministic results. If not provided, defaults to a seed derived from Date.now()

[ ] Rewrite current client to return its results formatted as a library
[ ] Rewrite current client to use this args format
[ ] Check version is set and compatible
[ ] Support count
[ ] Support count_type
[ ] Support omit
[ ] Support random sort
[ ] Support any sort
[ ] Support sort_reversed
[ ] Support seed
[ ] Support filter_before and filter_after


Return new immutable state instead of mutating previous state

Hi! I used this starter as a template and ran into an issue where React was struggling with multiple 'add to cart' buttons on a page. This should help the provider re-render more reliably when 'set' is called. Thanks for making this starter, it was a great help!

Thanks for the PR!


Update memory.hpp to adapt 14.21

@Xuemantou You are so good，I test it and it work well.
Please merge it @R3nzTheCodeGOD

in  Chinese servers it will result in a ban 3 -7 day


Long Installation Time and Continuous Version Attempt with "pip install metagpt" under Python 3.10.0

Description:
I attempted to install the "metagpt" package using "pip install metagpt" under Python 3.10.0. However, the installation process has been running for over 8 hours without completion. Upon inspecting the logs, it seems that the installation is continuously attempting different packages and versions, resulting in the extended duration of the process.
Steps to Reproduce:
Install Python 3.10.0.
Run "pip install metagpt" to install the "metagpt" package.
Expected Behavior:
The installation process should complete in a reasonable amount of time without continuously attempting different packages and versions.
Actual Behavior:
The installation process has been running for over 8 hours without completion, and it's continuously attempting different packages and versions.
Screenshots or logs
INFO: This is taking longer than usual. You might need to provide the dependency resolver with stricter constraints to reduce runtime. If you want to abort this run, you can press Ctrl + C to do so. To improve how pip performs, tell us what happened here: https://pip.pypa.io/surveys/backtracking
INFO: pip is looking at multiple versions of multidict to determine which version is compatible with other requirements. This could take a while.
Collecting multidict<7.0,>=4.5
Downloading https://maven.tuya-inc.top/repository/pypi-group/packages/multidict/6.0.4/multidict-6.0.4-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (114 kB)
|████████████████████████████████| 114 kB 6.6 MB/s
INFO: pip is looking at multiple versions of networkx to determine which version is compatible with other requirements. This could take a while.
INFO: pip is looking at multiple versions of mypy-extensions to determine which version is compatible with other requirements. This could take a while.
INFO: This is taking longer than usual. You might need to provide the dependency resolver with stricter constraints to reduce runtime. If you want to abort this run, you can press Ctrl + C to do so. To improve how pip performs, tell us what happened here: https://pip.pypa.io/surveys/backtracking
INFO: This is taking longer than usual. You might need to provide the dependency resolver with stricter constraints to reduce runtime. If you want to abort this run, you can press Ctrl + C to do so. To improve how pip performs, tell us what happened here: https://pip.pypa.io/surveys/backtracking
Downloading https://maven.tuya-inc.top/repository/pypi-group/packages/multidict/6.0.3/multidict-6.0.3-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (114 kB)
|████████████████████████████████| 114 kB 6.2 MB/s
Downloading https://maven.tuya-inc.top/repository/pypi-group/packages/multidict/6.0.2/multidict-6.0.2-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (114 kB)
|████████████████████████████████| 114 kB 6.4 MB/s
Downloading https://maven.tuya-inc.top/repository/pypi-group/packages/multidict/6.0.1/multidict-6.0.1-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (114 kB)
|████████████████████████████████| 114 kB 6.7 MB/s
Downloading https://maven.tuya-inc.top/repository/pypi-group/packages/multidict/6.0.0/multidict-6.0.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (114 kB)
|████████████████████████████████| 114 kB 7.0 MB/s
Downloading https://maven.tuya-inc.top/repository/pypi-group/packages/multidict/5.2.0/multidict-5.2.0-cp310-cp310-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_12_x86_64.manylinux2010_x86_64.whl (175 kB)
|████████████████████████████████| 175 kB 6.8 MB/s
Downloading https://maven.tuya-inc.top/repository/pypi-group/packages/multidict/5.1.0/multidict-5.1.0.tar.gz (53 kB)
|████████████████████████████████| 53 kB 7.4 MB/s
Installing build dependencies ... done
Getting requirements to build wheel ... done
Preparing wheel metadata ... done
INFO: pip is looking at multiple versions of multidict to determine which version is compatible with other requirements. This could take a while.
Downloading https://maven.tuya-inc.top/repository/pypi-group/packages/multidict/5.0.2/multidict-5.0.2.tar.gz (53 kB)
|████████████████████████████████| 53 kB 7.9 MB/s
Installing build dependencies ... done

Most of dependencies of metagpt have a specified version.
And multidict is not a direct dependency of MetaGPT; rather, it should be a dependency of one of MetaGPT's dependencies.

Generally this is how I solve the problem, but it's not perfect
Try this:
git clone https://github.com/geekan/MetaGPT && cd MetaGPT && pip install --upgrade -e .
And figure out what package makes it stuck. Set the package a stable version in requirements.txt

Try this:

Create a new virtual environment to isolate the dependencies for your project. You can use tools like venv or conda to create a virtual environment.
For example, using venv:
python -m venv myenv
source myenv/bin/activate

Inside the virtual environment, upgrade pip to the latest version:
pip install --upgrade pip

Install the required packages one by one, specifying the compatible versions mentioned in the error message:
pip install websockets~=12.0
pip install tokenizers!=0.11.3,<0.14,>=0.11.1

Install the metagpt package:
pip install metagpt==0.7.6

Install the transformers package:
pip install transformers==4.24.0

If you have a requirements.txt file, update it with the specific versions of the packages that are compatible with each other.
For example:
metagpt==0.7.6
transformers==4.24.0
websockets~=12.0
tokenizers!=0.11.3,<0.14,>=0.11.1

Then, you can install the packages from the requirements.txt file using:
pip install -r requirements.txt

It's always a good practice to use virtual environments to manage project-specific dependencies and avoid conflicts with other projects or system-wide packages.

Yes, I created the Python 3.10.0 environment using pyenv.
I tried again these past few days, patiently waiting until the command finished. It took nearly 13 hours, and in the end, I discovered it was due to the low version of pip (21.2.3).
After upgrading pip to version 24.0, it took about 10 minutes for pip install metagpt to succeed.
Thank you all for your help. I believe we can close this issue now.


⚠ ClamAV has degraded performance

In 91c1157, ClamAV (https://spamassassin.apache.org/) experienced degraded performance:

HTTP code: 200
Response time: 234 ms

Resolved: ClamAV performance has improved in 5c3d7c2 after 8 minutes.


iOS app generated from basic setup should be submittable

Issue details
Use LibGDX setup tool to generate a basic iOS app. Attempting to submit to app store fails due to several missing requirements. We should probably start new developers off on the right foot by having the minimum requirements in the generated iOS app, so they can start developing instead of troubleshooting the setup. I'll make a PR to improve this if I have time, just documenting the idea right now.
Reproduction steps/code

Download libgdx setup app
Create basic ios project
Attempt to submit to app store

Upload fails:

Missing 64 bit support
No minimum iOS version set
Setting to minimum iOS 7 requires additional icon files to be created
No handling of the "requires full screen" plist key

Version of LibGDX and/or relevant dependencies
1.93
Please select the affected platforms

[X] iOS (robovm)

64 bit is supported, not sure what you mean by that it is missing.
There should be a minimum iOS version set of iOS 6, can you pastebin a full log of building your artifact.

Just to clarify - 64 bit is not enabled in the basic app by the setup tool in the robovm.xml., it only lists thumbv7, which disables 64 bit support.
https://github.com/libgdx/libgdx/blob/31e73274718e66ad3a50eb081c3f85b24f4114d9/extensions/gdx-setup/src/com/badlogic/gdx/setup/resources/ios/robovm.xml
There is no minimum iOS version set in the Info.plist.
https://github.com/libgdx/libgdx/blob/31e73274718e66ad3a50eb081c3f85b24f4114d9/extensions/gdx-setup/src/com/badlogic/gdx/setup/resources/ios/Info.plist.xml

The robovm.xml only allows to specify the default arch to compile for. You
can't specify multiple archs iirc. For that, you either use the IPA export
dialog in the IDE, or the Gradle plugin parameters, either as CLI args, or
in build.gradle.
On Jul 19, 2016 4:20 PM, "Eric Nondahl"<EMAIL_ADDRESS>wrote:

Just to clarify - 64 bit is not enabled in the basic app by the setup tool
in the robovm.xml., it only lists thumbv7, which disables 64 bit support.
https://github.com/libgdx/libgdx/blob/31e73274718e66ad3a50eb081c3f85b24f4114d9/extensions/gdx-setup/src/com/badlogic/gdx/setup/resources/ios/robovm.xml
There is no minimum iOS version set in the Info.plist.
https://github.com/libgdx/libgdx/blob/31e73274718e66ad3a50eb081c3f85b24f4114d9/extensions/gdx-setup/src/com/badlogic/gdx/setup/resources/ios/Info.plist.xml
—
You are receiving this because you are subscribed to this thread.
Reply to this email directly, view it on GitHub
https://github.com/libgdx/libgdx/issues/4198#issuecomment-233647897, or mute
the thread
https://github.com/notifications/unsubscribe-auth/AAfYBHqQ0zKGYcGhbiYGY_WVpWIZN_Qtks5qXN1JgaJpZM4JPxDD
.

That would mean that all builds would automatically build 64 bit also, which isn't something you want to be doing during development.  As I said, there is no minimum set in the info.plist, but it should be set by robovm. Please pastebin the log of building.

Hm, I would expect the basic createIPA gradle task to generate an app that is submittable by default. 64bit and thumbv7 can be enabled in robovm.xml by just removing the line that only specifies thumbv7.
All of the errors listed above were errors during the itunesconnect upload, if I have time I will redo the process and paste the exact wording here.

That may be the case re:createIPA. Should modify Gradle template to build
thumb/arm64 by default.
On Jul 19, 2016 4:26 PM, "Eric Nondahl"<EMAIL_ADDRESS>wrote:

Hm, I would expect the basic createIPA gradle task to generate an app
that is submittable by default. 64bit and thumbv7 can be enabled in
robovm.xml by just removing the line that only specifies thumbv7.
All of the errors listed above were errors during the itunesconnect
upload, if I have time I will redo the process and paste the exact wording
here.
—
You are receiving this because you commented.
Reply to this email directly, view it on GitHub
https://github.com/libgdx/libgdx/issues/4198#issuecomment-233649722, or mute
the thread
https://github.com/notifications/unsubscribe-auth/AAfYBGlSdPUMhYa-rzBMG7xhtROsk_O0ks5qXN6bgaJpZM4JPxDD
.

Updated issue to pull out the iOS 7 based changes.

Pastebin of initial itunes upload errors from sample iOS app: http://pastebin.com/8Us93Dgz
Note the 64 bit errors and the minimum OS Version issue, along with the multitasking support issue.

gradle.build
robovm {
	archs = "thumbv7:arm64"
}

We are now generating a config that creates both the thumbv7 and arm64 slices in the IPA. The minimum version is set by the RoboVM compiler if omitted.


ThreadContext random fail with IndexOutOfRangeException

We use MessageFilter and today we comes up a random exception:
System.IndexOutOfRangeException: Index was outside the bounds of the array.
   at System.Windows.Forms.Application.ThreadContext.ProcessFilters(MSG& msg, Boolean& modified)
   at System.Windows.Forms.Application.ThreadContext.PreTranslateMessage(MSG& msg)
   at System.Windows.Forms.Application.ThreadContext.System.Windows.Forms.UnsafeNativeMethods.IMsoComponent.FPreTranslateMessage(MSG& msg)
   at System.Windows.Forms.Application.ComponentManager.System.Windows.Forms.UnsafeNativeMethods.IMsoComponentManager.FPushMessageLoop(IntPtr dwComponentID, Int32 reason, Int32 pvLoopData)
   at System.Windows.Forms.Application.ThreadContext.RunMessageLoopInner(Int32 reason, ApplicationContext context)
   at System.Windows.Forms.Application.ThreadContext.RunMessageLoop(Int32 reason, ApplicationContext context)
   at System.Windows.Forms.Application.Run(Form mainForm)

In release notes from 4.6 is written that this is fixed (internal issue id [1072924]), but File Version of System.Windows.Forms.dll is 4.7.3163.0
We use Application.RemoveMessageFilter in Dispose method, which can be called by Finalizer.
Could this be the problem, when MessageFilter are not removed from GUI thread?

Hi @trivalik  - we had shipped a fix to issues related to reentrancy in message filters in 4.6.1, see this code on reference source: https://referencesource.microsoft.com/#System.Windows.Forms/winforms/Managed/System/WinForms/Application.cs,3546  where we added a re-entrance guard - inProcessFilters
This fix was considered breaking, thus it is activated only when application is retargeted to 4.6.1, or opts in into this change by adding
<runtime>
    <!-- AppContextSwitchOverrides values are in the form of 'key1=true|false;key2=true|false  -->
    <AppContextSwitchOverrides value="Switch.System.Windows.Forms.DontSupportReentrantFilterMessage=false" />
</runtime>

to the app.config file. And application should run on the 4.6.1, or newer, Framework, available here:
https://www.microsoft.com/en-us/download/details.aspx?id=49982
More details: https://docs.microsoft.com/en-us/dotnet/framework/migration-guide/mitigation-custom-imessagefilter-prefiltermessage-implementations

Thanks for this detailed information. Since this happens very seldom, I hope it will work.


Added custom browserContext for each session

Does this fix it? I'm curious on why this would fix it when our --user-data-dir code like 5 lines down would not.

That's weird. It works just this way. Also when I'm looking into the old 0.3.5 version it looks similar to what I'm suggesting.
https://deno.land/x/astral@0.3.5/src/browser.ts?source#L242

Nevermind. What a rookie mistake I oversaw. We're applying the args parameter to the binargs before adding the --user-data-dir parameter. 😄 I will edit that right now.

We're applying the args parameter to the binargs before adding the --user-data-dir parameter. 😄 I will edit that right now.

Ahhh, right. Thanks for catching this.


Possible to dynamically render the tabs and slides?

@JKnorr91 awesome job! but is it possible to use ng-repeat to load tabs and slide contents?
thanks

Hey @connect-dips !
I made a fork of the project and it's working with dynamic tabs/slides.
Fork: https://github.com/leoruhland/ion-slides-tabs
Example with dynamic tabs/slides: https://leoruhland.github.io/ion-slides-tabs/example/example3.html

@leoruhland how to inject html in tabsarray
$scope.tabsArray = [
{title: 'First Tab', content: "app/toplinesales/toplinesales.html"},
{title: '2', content: 'tab 2'},
{title: 'A really long title', content: 'Tab 3'},
{title: 'Tab 4', content: 'Tab 4'},
{title: 'Tab 5', content: 'Tab 5'},
{title: 'Tab 6', content: 'Tab 6'},
{title: 'Tab 7', content: 'Tab 7'},
{title: 'Tab 8', content: 'Tab 8'},
{title: 'Tab 9', content: 'Tab 9'},
{title: 'Last one', content: 'Tab 10'}
];

Very good Job but there are 2 issues. First of all in example 3 which use the ng-repeat for the tabs is work only with title, if you try to rename the title to category is not work.Also if you have 2 titles with the same value , fro example title:'tabs 5; and title:'tabs 5'  the ng-repeat stop at tabs 5 so the tabs 6 and above is not showing.

@leoruhland This is not fully dynamic as when the "tabsArray" changes (removes items) ion-slide-tab-label is not updating. It works when adding more items.


Add a size method to UpdateCtx.

I found myself needing this, for a widget that wants to update its internal state based on changes to data, but needs the size to do so (think of something like a scroll bar, whose state depends on the viewport size).
More generally, is there a rationale somewhere for which contexts have which functions? For example, I see that LifeCycleCtx is also missing size...

Yeah I think this is something that's fine to have on LifeCycleCtx as well. Feel free to add it as well.

Ok, I just added it to LifeCycleCtx as well.


How to add a property to a SubmodelElementCollection?

Hi,
How do I add a property to a SubmodelElementCollection?
With the following code I am able to create and add a SubmodelElementCollection to a Submodel.
smc= model.SubmodelElementCollectionUnordered(id_short="TestSME")
submodel.submodel_element.add(smc)

I am not able to add a property to that smc. The following code below gives error: AttributeError: 'SubmodelElementCollectionUnordered' object has no attribute 'submodel_element'.
smc.submodel_element.add(property_)
Is there a way to add a property to a SubmodelElementCollection?

Yes, SubmodelElements are contained in the value attribute of a SubmodelElementCollection. Thus, you should be able to add the propety via
smc.value.add(property_)

or alternatively
smc.add_referable(property_)

Yes, SubmodelElements are contained in the value attribute of a SubmodelElementCollection. Thus, you should be able to add the propety via
smc.value.add(property_)

or alternatively
smc.add_referable(property_)

Nice, thank you!


Limit permission to get files only from the UploadsS3Bucket

@brunomoutinho thanks! Periodically we make betas and stable releases as needed. I think with these changes we are ready to release a new minor version. Will follow up with a beta release shortly.


Zero downtime doppelganger protection

Problem description
Current implementation of doppelganger protection does not differentiate between a simple restart and starting the validator on a new machine. This causes 2-3 missed attestations after every restart such as when upgrading Lodestar to a newer version but DP does not provide any protection in this case.
For some users (e.g. on dappnode), DP is enabled by default and every package upgrade causes unnecessary downtime which causes bad user experience.
Solution description
We should make our DP implementation a bit smarter and be able to differentiate between a restart and a new installation. Validator duties should only be skipped if it is really required.
This can be achieved by looking at the local slashing protection DB and if the validator produced an attestation in the previous epoch it means that the validator client was just restarted and DP can be skipped for this validator (https://github.com/ChainSafe/lodestar/compare/unstable...nflaig/zero-downtime-doppelganger).
It might even be safer in this case to start attestation right away because if two validator clients are started at the same time and one of them has an existing DB it would prevent slashing, whereas if both wait for 2-3 epochs no chain activity would be detected and both instances would start attesting at the same time causing validators to be slashed.
Additional context
Similar approach is described in https://github.com/prysmaticlabs/prysm/issues/7985#issuecomment-843209422 and https://github.com/status-im/nimbus-eth2/issues/3083.

I looked into finishing the implementation I started in https://github.com/ChainSafe/lodestar/compare/unstable...nflaig/zero-downtime-doppelganger but the issue is that making addSigner in validator store async due to registerValidator in doppelganger serivce becoming async is a bit problematic. This is required because we have to load data from the slashing protection db.
https://github.com/ChainSafe/lodestar/blob/12f9e11cde669122565a2324436e254d2093c886/packages/validator/src/services/validatorStore.ts#L285
https://github.com/ChainSafe/lodestar/blob/12f9e11cde669122565a2324436e254d2093c886/packages/validator/src/services/doppelgangerService.ts#L63
It makes the whole validator initialization async because we have to make sure that signers are added before executing any other code like registering validator with builder / beacon node.
https://github.com/ChainSafe/lodestar/blob/12f9e11cde669122565a2324436e254d2093c886/packages/validator/src/validator.ts#L122-L123
It is also critical that the validator is registered as doppelganger before any other code can use the pubkey (e.g. to fetch duties) as this would impend the security of the doppelganger protection.
I don't like making the validator store initialization async but on the other hand we are using this pattern all over the place for other modules. The validator initilization itself is already async anyways so it might be ok to introduce this change to make this feature possible.
https://github.com/ChainSafe/lodestar/blob/a11427edba4a0cabcb4b212a9eeef78199bea246/packages/validator/src/validator.ts#L193
Looking for some feedback on this or possible alternatives / ideas.


Remove queries versioning and related caching system

QueryTemplates will be used instead of the current caching system

fixed by b9a238e


Create dataset loader for WikiText-TL-39

Dataloader name: wikitext_tl_39/wikitext_tl_39.py
DataCatalogue: http://seacrowd.github.io/seacrowd-catalogue/card.html?wikitext_tl_39

Dataset
wikitext_tl_39

Description
A benchmark Language Modeling dataset for Tagalog. The dataset construction was done similar to that of the WikiText Long Term Dependency Language Modeling Dataset, with a some differences, such as in how Wikipedia was scraped and how the vocabulary was created. The dataset contains 39 Million tokens in the training set.

Subsets
-

Languages
fil

Tasks
Language Modeling

License
GNU General Public License v3.0 (gpl-3.0)

Homepage
https://s3.us-east-2.amazonaws.com/blaisecruz.com/datasets/wikitext-tl-39/wikitext-tl-39.zip

HF URL
https://huggingface.co/datasets/wikitext_tl39

Paper URL
https://arxiv.org/pdf/1907.00409.pdf

#self-assign

will open PR this weekend


Able to remove tracking parameters from shared links

Every time I use the share link, I have to manually remove those useless tracking parameters. I hope to add a feature that allows me to get a clean link just by clicking the share button.

https://github.com/BewlyBewly/BewlyBewly?tab=readme-ov-file#-introduction

BewlyBewly mainly focuses on page adjustments and optimization rather than improving functionality and efficiency.

Bilibili Evolved already has a similar feature, and it provides more additional practical functionalities


Add action for other plugins to get patreon data

With this action, other plugins can use patreon data, which is not explicitly stored in user_meta. For example, other plugins can check for the pledge amount.

Thanks @flogc! we are currently working on a complete refactor of this plugin and will try to include this feature in the new version.

Sounds good. Otherwise I could make a new pull request after your rework. ;)

Plugin now has an abundance of hooks and filters to effect this functionality easily.
https://paper.dropbox.com/doc/Patreon-WordPress-Filters-5yIOc9WglrqqvjJjNzT6f
https://paper.dropbox.com/doc/Patreon-WordPress-Action-Hooks--AuOwlqtiRWmXkEajT66deKvZAg-glW5B5uPdwLFcbAC9Fna8
Therefore, im closing the PR.


Error during template rendering

Reverse for 'trending' with arguments '()' and keyword arguments '{u'page': ''}' not found. 1 pattern(s) tried: ['crowdcop_web/trending/(?P[0-9]+)/$']
This is related to your trending implementation.

I just fixed this loading of the index, however on my test machine staticfiles won't load.

This works on both the localhost and the server, just in time for the UGRS!


[Brave] Display Issue : Zooming at 110% Resolves Application Fit

In the Brave browser, the application does not take up the entire screen at 100% zoom of the browser. However, if I increase the zoom to 110%, then the application completely fits on the screen.
At 100% of the browser

At 110% of the browser

@ParbhatKataria1 Thanks for reporting this issue.
By default, Zulip doesn't try to occupy the full screen. It only does so when the user has zoomed in sufficiently enough (in your case that is 110%). That being said, you can always enable full width display which will result in the full width of the display being used by following the instructions on this link - https://zulip.com/help/enable-full-width-display
Feel free to close this issue if this solves the problem.

Closing this issue because as @sbansal1999 noted the web-app is not designed to automatically take up the full width of the browser, and there is a user display setting for folks who would like to have that behavior.


improve ci tests

test do run  but main dont on pull (and so there are no builds run - I'd like to see pulls build too - so we see if it fails)

test do run but main dont on pull (and so there are no builds run - I'd like to see pulls build too - so we see if it fails)

Ahh I think that is because I added depends_on: [ test ] to main.yml, but the CI is still running on some quite old version which does not have #270 & #326.

yes from code perspective I was going to lgtm it but having a final look at the ci and found that issue
we need to upgrade our ci! cc @laszlocph


get Solid NUnit tests running in GHA

So I spent a few hours trying to get NUnit 2.6.4 tests running in GHA.  So far I haven't succeeded.
What I know:

NUnit tests pass in Visual Studio in the Test Explorer on VS2022 Community:

TeamCity uses an opaque "TeamCity Nunit runner" to run the tests successfully, but I don't know how to use whatever it uses under the hood.

<Target Name="Test" DependsOnTargets="Build">
    <ItemGroup>
      <TestAssemblies Include="$(teamcity_build_checkoutDir)/output/release/*Tests.dll;" Exclude="" />
    </ItemGroup>
    <NUnitTeamCity Assemblies="@(TestAssemblies)" ExcludeCategory="SkipOnTeamCity" />
  </Target>

AFAIK the appropriate way to run NUnit v2 on the command line is through the NUnit Console Runner.
NUnit.Runners.Net<IP_ADDRESS>\tools\nunit-console.exe can accept a .dll file with tests in it or a csproj file for the test project.  When I point it at the .dll I get the error:
System.BadImageFormatException: Could not load file or assembly 'SolidGui.Tests, Version=<IP_ADDRESS>, Culture=neutral, PublicKeyToken=null' or one of its dependencies. An attempt was made to load a program with an incorrect format.

When I point it at the csproj file I get a different error (on GHA) that it cannot find Solid.exe. So far I get different behavior between GHA and local for the csproj file but I get the same error if I point nunit-console.exe at the .dll
So I'm stuck and have decided to abandon efforts for now, just ensuring that the tests pass locally.  I will try again once the entire project has been upgraded to .Net 8 - I think it will be easier to address this with more modern tooling.

Unit tests are all green as of 14e5a9fc0c6d9890fe06497544ed10d9d1295278


Bug Report: Some Books in Recommended Book Section not working Properly

Reproduction steps
In the recommended book section -

The books

Expected behavior
It should open the PDF version after clicking on Download as pdf

Actual Behavior
It actually looks like

👀 Have you spent some time to check if this issue has been raised before?

[X] I checked and didn't find similar issue

🏢 Have you read the Code of Conduct?

[X] I have read the Code of Conduct

I want to work on this issue under GSSoC'22.

@Jyoti6828 Go for it!

Hey @SauravMukherjee44 , I am a GSSOC'22 Contributor . Can  you please assign this issue to me . I have send the PR solving the above issue . You can review and merge it .


Fix submit analysis task

** Depends on: **
PR #497
What this PR does / why we need it:
Which issue(s) this PR fixes (optional, use fixes #<issue_number>(, fixes #<issue_number>, ...) format, where issue_number might be a GitHub issue, or a Jira story (FLPATH-xxxx):
Fixes #
Change type

[ ] New feature
[ ] Bug fix
[ ] Unit tests
[ ] Integration tests
[ ] CI
[ ] Documentation
[ ] Auto-generated SDK code

Impacted services

[ ] Workflow Service
[ ] Notification Service

Checklist

[ ] Subject and description added to both, commit and PR.
[ ] Relevant issues have been referenced.

/unhold


Add Azure OpenAI Support

Describe the feature or improvement you're requesting
Discussion on how adding azure support starting at this message.

Apparently the MS Entra Id route is cumbersome. I've made another change to support the non-Entra-Id case. The openai value needs to be created as follows
def for_azure(azure_api_key) do
%OpenaiEx{
_http_headers: [{"api-key", "#{azure_api_key}"}]
}
end

then the path map has to be attached
azure_openai = for_azure(azure_key) |> OpenaiEx._with_ep_path_mapping(&azure_ep_path_map/1)

Please see if this works for you.

I have added what I believe to be the support functions needed for azure. The user only needs to call a single function for Azure. For non entra-id, you need to do
openai = OpenaiEx._for_azure(azure_api_id, resource_name, deployment_id, api_version)

for Entra Id it becomes
openai = OpenaiEx.new(entra_id) |> OpenaiEx._for_azure(resource_name, deployment_id, api_version)

and then use the rest of the API as is.
This is only applicable for the "/completions", "/chat/completions" and "/embeddings" end points.

@raulchedrese Since this branch is based on your fixes and references, I would like to give you co-author credit on a commit. Would that be OK?

👍🏽 sure. Thanks for adding this!


Additional tool

Malicious File Analysis/Hosted Automated Analysis.
https://hybrid-analysis.com
Been my goto for a while now. A bit slow lately, but super in depth.

Thanks!  Awesome tool.  This will be added in the next update.


When connecting with MQTTLens, program throws an error

When using the NON TLS demo on a processor, and trying to connect with MQTTLens, there is an error that gets thrown.
Steps to recreate:

Load NON TLS Demo to processor
Using MQTTLens with default settings, connect to processor
Look at error log.

Error:
5. Error: splusmanagerapp.exe [App 4] # 2021-01-13 06:25:31  # Exception:Exception in customer callback function - System.InvalidOperationException: Sequence contains no elements
at System.Linq.Enumerable.First[TSource](IEnumerable`1 source)
at sahajquinci.MQTT_Broker.ServerBase.GetClientByIndex(UInt32 client  6. Error: splusmanagerapp.exe [App 4] # 2021-01-13 06:25:31  # Index, Boolean isWebSocketClient)
at sahajquinci.MQTT_Broker.TCPServer.DisconnectClient(UInt32 clientIndex, Boolean withDisconnectPacket)
at sahajquinci.MQTT_Broker.TCPServer.ConnectionCallback(TCPServer server, UInt32 clientIndex)
at Crestron  7. Error: splusmanagerapp.exe [App 4] # 2021-01-13 06:25:31  # .SimplSharp.CrestronSockets.TCPServer.e(IAsyncResult A_0)
at System.Net.LazyAsyncResult.InvokeCallback(Boolean asyncCompletion)
at System.Net.Sockets.Socket.WorkerThread.doWork()
at System.Net.Sockets.Socket.WorkerThread.doWorkI(Object o)
8. Error: splusmanagerapp.exe [App 4] # 2021-01-13 06:25:31  # at System.Threading.ThreadPool.WorkItem.doWork(Object o)
at System.Threading.Timer.ring()

Error: splusmanagerapp.exe [App 4] # 2021-01-13 06:25:32  # Exception:Exception in customer callback function - System.InvalidOperationException: Sequence contains no elements
at System.Linq.Enumerable.First[TSource](IEnumerable`1 source)
at sahajquinci.MQTT_Broker.ServerBase.GetClientByIndex(UInt32 client 10. Error: splusmanagerapp.exe [App 4] # 2021-01-13 06:25:32  # Index, Boolean isWebSocketClient)
at sahajquinci.MQTT_Broker.TCPServer.DisconnectClient(UInt32 clientIndex, Boolean withDisconnectPacket)
at sahajquinci.MQTT_Broker.TCPServer.ConnectionCallback(TCPServer server, UInt32 clientIndex)
at Crestron 11. Error: splusmanagerapp.exe [App 4] # 2021-01-13 06:25:32  # .SimplSharp.CrestronSockets.TCPServer.e(IAsyncResult A_0)
at System.Net.LazyAsyncResult.InvokeCallback(Boolean asyncCompletion)
at System.Net.Sockets.Socket.WorkerThread.doWork()
at System.Net.Sockets.Socket.WorkerThread.doWorkI(Object o)
12. Error: splusmanagerapp.exe [App 4] # 2021-01-13 06:25:32  # at System.Threading.ThreadPool.WorkItem.doWork(Object o)
at System.Threading.Timer.ring()

You experience this problem only with MQTTLens correct ?

You experience this problem only with MQTTLens correct ?

It seems to be only with MQTTLens.  I am able to connect without issue using MQTTBox.

It seems to be only with MQTTLens.  I am able to connect without issue using MQTTBox.

I found the bug in the code.
MQTTLens connection packet results in an error during the initial connection phase.
This results in an exception that triggers  the process of disconnecting the client .
First thing disconnect client does is retrieve the client from a list of client through an Index, but the client doesn't exist.
The only question is why MQTTLens's ConnectionPacket fails and all the other clients I've tried don't

I found the bug in the code.
MQTTLens connection packet results in an error during the initial connection phase.
This results in an exception that triggers  the process of disconnecting the client .
First thing disconnect client does is retrieve the client from a list of client through an Index, but the client doesn't exist.
The only question is why MQTTLens's ConnectionPacket fails and all the other clients I've tried don't

I did test it with MQTTBox without an issue, but MQTTLens seems to have its own bug in it where I can not connect via ws.  When doing so, it reverts to tcp.

I did test it with MQTTBox without an issue, but MQTTLens seems to have its own bug in it where I can not connect via ws.  When doing so, it reverts to tcp.

As seen together MQTTLens is not MQTT 3.1.1 compliant. for this reason  I close this issue

As seen together MQTTLens is not MQTT 3.1.1 compliant. for this reason  I close this issue


Sending same file twice

I am having problems when sending same file twice, using the following method:
let response = await axios.get(json.body, { responseType: 'arraybuffer'});
let buffer = Buffer.from(response.data, 'binary')
wap.sendMediaMessage(buffer, fileType.mime, type, jid, json.caption, undefined, false, json.filename)

The first time, it is sent correctly, but the second time, it seems that Whatsapp ignores sending the file.  How do you suggest is the best way to send a file?
Is there a way to just send the url of the image directly to the user?

After a lot of debugging, I was able to pinpoint the problem.
on the encryptMedia function, there is a token being computed that works both as part of the url, as well as a GET parameter being sent to the request:
`https://${hostname}/${path}/${messageTag}?auth=${auth}&token=${token}`

When this token includes a "/" on it's base64, then the request fails with the following error:
debug_info: {
    retriable: false,
    type: 'INVALID_MEDIA_TYPE',
    message: 'Invalid media type'
}

Whatsapp interprets the character as part of the URL.  I am not familiar with the information being sent, but maybe you could shed a light on this and I can clone and pull request the fix.
Thanks!


I cannot delete files & folders anymore

Description
Whenever I try deleting a file or folder, even after running Files as admin, the administrator privilege prompt comes up, but clicking the CTA does nothing.

Steps To Reproduce

Run Files
Try deleting something
Press the prompt's CTA
Nothing happens

Requirements

Fix bug that requires administrator privilege when it is already granted

Files Version
<IP_ADDRESS>
Windows Version
10.0.22631.2861
Log File
debug.log

Thanks for the report. What happens if you try in Windows File Explorer

You're right some weird things happened with the permissions on an OS level


Remove storage flags and experimental subcommand tests

Addresses DCOS-15193 and partially DCOS-18769

run linux integration tests

run linux integration tests

run linux integration tests

@jsancio @larioj can you review this? Thanks!

@jsancio created https://jira.mesosphere.com/browse/DCOS_OSS-1761
@kensipe Can you review this? Thanks! (linux integration tests were passed in this latest build - https://jenkins.mesosphere.com/service/jenkins/job/DCOS-CLI/job/mesosphere-dcos-cli/job/linux-integration-tests/311/ not sure why github doesn't pick it up)

run all integration tests

Thank you @takirala , always nice to drop some code :)


Zephyr devicetree support for the bloodlight board

[ ] TOBEDEFINED

Moved to here: https://github.com/CodethinkLabs/bloodlight-zephyr


Compile futureresrore

hello .
i  have problem.
I can't figure out how to compile futurerestore and img4tool correctly.
I also found a compiled futurerestore specifically for inferius, but I don’t know in which folder to insert it.
I need your help.
Mac OS Catalina.

Git clone futurerestore
Put img4tool in futurerestore
And  compile futurerestore?


Issue with running Phoenix on Terra

My workflows for Phoenix on Terra keep failing and am not sure what I am doing wrong. I redownloaded the new kraken database since originally, I had characters Terra didn't like. After that, I resubmitted and the workflow continued and then it failed. Any help to try to fix what I am doing would be greatly appreciated!! :)
Phoenix.log 230726.docx

Hi @lindseyb1234,
Looks like your database is named k2_eupathdb48_20230407.tar.gz the eupath portion of this name means you used the Eukaryotic pathogen genomes kraken database and it doesn't have the files that PHX is expecting. This database also won't work as we need a Bacterial genome database.  Use the Standard-8 version of the kraken database:

Here is the link to use: https://genome-idx.s3.amazonaws.com/kraken/k2_standard_08gb_20230605.tar.gz

Thank you so much for your help!! I am glad it was a simple fix! I redownloaded the correct database and it finally went through and was successful. Thank you so so much again for all your help!!

Glad you got it going! Also, be aware that next week there will be a new release v2.0.2 to address a bug with MLST we found. No changes to how you run it though so just follow the steps you just did and it should be good.


[federation] __resolveReference resolver type is incorrect

Describe the bug
The generated code uses regular resolver type for the __resolvereference field, when federation is enabled, while the actual type is missing the args argument, and only has (parent, context, info). See Documentation for confirmation.

@kamilkisiela you recent changes also solves this?

@dotansimha no