text:
from __future__ import print_function
import os
import sys
import tempfile

import numpy as np

import tables
from tables import (
    StringCol, BoolCol, FloatCol, ComplexCol, EnumCol,
    Int8Col, UInt8Col, Int16Col, UInt16Col, Int32Col, UInt32Col,
    Int64Col, Float32Col, Float64Col, Time64Col
)
from tables.tests import common
from tables.tests.common import allequal
from tables.tests.common import unittest
from tables.tests.common import PyTablesTestCase as TestCase

typecodes = ['b', 'h', 'i', 'l', 'q', 'f', 'd']
# UInt64 checking disabled on win platforms
# because this type is not supported
if sys.platform != 'win32':
    typecodes += ['B', 'H', 'I', 'L', 'Q', 'F', 'D']
else:
    typecodes += ['B', 'H', 'I', 'L', 'F', 'D']
typecodes += ['b1']   # boolean

if hasattr(tables, 'Float16Atom'):
    typecodes.append('e')
if hasattr(tables, 'Float96Atom') or hasattr(tables, 'Float128Atom'):
    typecodes.append('g')
if hasattr(tables, 'Complex192Atom') or hasattr(tables, 'Conplex256Atom'):
    typecodes.append('G')

byteorder = {'little': '<', 'big': '>'}[sys.byteorder]

class BasicTestCase(TestCase):
    """Basic test for all the supported typecodes present in NumPy.

    All of them are included on PyTables.

    """
    endiancheck = 0

    def WriteRead(self, testArray):
        if common.verbose:
            print('\n', '-=' * 30)
            print("Running test for array with typecode '%s'" %
                  testArray.dtype.char, end=' ')
            print("for class check:", self.title)

        # Create an instance of HDF5 Table
        self.h5fname = tempfile.mktemp(".h5")
        try:
            with tables.open_file(self.h5fname, mode="w") as self.h5file:
                self.root = self.h5file.root

                # Create the array under root and name 'somearray'
                a = testArray
                self.h5file.create_array(self.root, 'somearray', a,
                                         "Some array")

            # Re-open the file in read-only mode
            with tables.open_file(self.h5fname, mode="r") as self.h5file:
                self.root = self.h5file.root

                # Read the saved array
                b = self.root.somearray.read()

                # For cases that read returns a python type instead of a
                # numpy type
                if not hasattr(b, "shape"):
                    b = np.np.array(b, dtype=a.dtype.str)

                # Compare them. They should be equal.
                # if not allequal(a,b, "numpy") and common.verbose:
                if common.verbose:
                    print("Array written:", a)
                    print("Array written shape:", a.shape)
                    print("Array written itemsize:", a.itemsize)
                    print("Array written type:", a.dtype.char)
                    print("Array read:", b)
                    print("Array read shape:", b.shape)
                    print("Array read itemsize:", b.itemsize)
                    print("Array read type:", b.dtype.char)

                type_ = self.root.somearray.atom.type

                # Check strictly the array equality
                self.assertEqual(type(a), type(b))
                self.assertEqual(a.shape, b.shape)
                self.assertEqual(a.shape, self.root.somearray.shape)
                self.assertEqual(a.dtype, b.dtype)
                if a.dtype.char[0] == "S":
                    self.assertEqual(type_, "string")
                else:
                    self.assertEqual(a.dtype.base.name, type_)

                self.assertTrue(allequal(a, b, "numpy"))
        finally:
            # Then, delete the file
            if os.path.exists(self.h5fname):
                os.remove(self.h5fname)

    def test00_char(self):
        """Data integrity during recovery (character objects)"""

        a = np.array(self.tupleChar, 'S'+str(len(self.tupleChar)))
        self.WriteRead(a)

    def test01_char_nc(self):
        """Data integrity during recovery (non-contiguous character objects)"""

        a = np.array(self.tupleChar, 'S'+str(len(self.tupleChar)))
        if a.shape == ():
            b = a               # We cannot use the indexing notation
        else:
            b = a[::2]
            # Ensure that this numpy string is non-contiguous
            if a.shape[0] > 2:
                self.assertEqual(b.flags['CONTIGUOUS'], False)
        self.WriteRead(b)

    def test02_types(self):
        """Data integrity during recovery (numerical types)"""

        for typecode in typecodes:
            if self.tupleInt.shape:
                a = self.tupleInt.astype(typecode)
            else:
                # shape is the empty tuple ()
                a = np.array(self.tupleInt, dtype=typecode)
            self.WriteRead(a)

    def test03_types_nc(self):
        """Data integrity during recovery (non-contiguous numerical types)"""

        for typecode in typecodes:
            if self.tupleInt.shape:
                a = self.tupleInt.astype(typecode)
            else:
                # shape is the empty tuple ()
                a = np.array(self.tupleInt, dtype=typecode)

            # This should not be tested for the rank-0 case
            if len(a.shape) == 0:
                raise unittest.SkipTest
            b = a[::2]

            # Ensure that this array is non-contiguous (for non-trivial case)
            if a.shape[0] > 2:
                self.assertEqual(b.flags['CONTIGUOUS'], False)
            self.WriteRead(b)

class Basic0DOneTestCase(BasicTestCase):
    # Rank-0 case
    title = "Rank-0 case 1"
    tupleInt = np.array(3)
    tupleChar = "4"

class Basic0DTwoTestCase(BasicTestCase):
    # Rank-0 case
    title = "Rank-0 case 2"
    tupleInt = np.array(33)
    tupleChar = "44"

class Basic1DOneTestCase(BasicTestCase):
    # 1D case
    title = "Rank-1 case 1"
    tupleInt = np.array((3,))
    tupleChar = ("a",)

class Basic1DTwoTestCase(BasicTestCase):
    # 1D case
    title = "Rank-1 case 2"
    tupleInt = np.array((0, 4))
    tupleChar = ("aaa",)

class Basic1DThreeTestCase(BasicTestCase):
    # 1D case
    title = "Rank-1 case 3"
    tupleInt = np.array((3, 4, 5))
    tupleChar = ("aaaa", "bbb",)

class Basic2DTestCase(BasicTestCase):
    # 2D case
    title = "Rank-2 case 1"
    # tupleInt = reshape(np.array(np.arange((4)**2)), (4,)*2)
    tupleInt = np.ones((4,)*2)
    tupleChar = [["aaa", "ddddd"], ["d", "ss"], ["s", "tt"]]

class Basic10DTestCase(BasicTestCase):
    # 10D case
    title = "Rank-10 case 1"
    # tupleInt = reshape(np.array(np.arange((2)**10)), (2,)*10)
    tupleInt = np.ones((2,)*10)
    # tupleChar = reshape(np.array([1],dtype="S1"),(1,)*10)
    # The next tuple consumes far more time, so this
    # test should be run in common.heavy mode.
    tupleChar = np.array(tupleInt, dtype="S1")

# class Basic32DTestCase(BasicTestCase):
#     # 32D case (maximum)
#     tupleInt = reshape(np.array((22,)), (1,)*32)
#     # Strings seems to be very slow with somewhat large dimensions
#     # This should not be run unless the numarray people address this problem
#     # F. Alted 2006-01-04
#     tupleChar = np.array(tupleInt, dtype="S1")

class GroupsArrayTestCase(common.TempFileMixin, TestCase):
    """This test class checks combinations of arrays with groups.

    It also uses arrays ranks which ranges until 10.

    """

    def test00_iterativeGroups(self):
        """Checking combinations of arrays with groups

        It also uses arrays ranks which ranges until 10.

        """

        if common.verbose:
            print('\n', '-=' * 30)
            print("Running %s.test00_iterativeGroups..." %
                  self.__class__.__name__)

        # Get the root group
        group = self.h5file.root

        i = 1
        for typecode in typecodes:
            # Create an array of typecode, with incrementally bigger ranges
            a = np.ones((2,) * i, typecode)
            # Save it on the HDF5 file
            dsetname = 'array_' + typecode
            if common.verbose:
                print("Creating dataset:", group._g_join(dsetname))
            self.h5file.create_array(group, dsetname, a, "Large array")
            # Create a new group
            group = self.h5file.create_group(group, 'group' + str(i))
            # increment the range for next iteration
            i += 1

        self._reopen()

        # Get the root group
        group = self.h5file.root

        # Get the metadata on the previosly saved arrays
        for i in range(1, len(typecodes)):
            # Create an array for later comparison
            a = np.ones((2,) * i, typecodes[i - 1])
            # Get the dset object hanging from group
            dset = getattr(group, 'array_' + typecodes[i-1])
            # Get the actual array
            b = dset.read()
            if not allequal(a, b, "numpy") and common.verbose:
                print("Array a original. Shape: ==>", a.shape)
                print("Array a original. Data: ==>", a)
                print("Info from dataset:", dset._v_pathname)
                print("  shape ==>", dset.shape, end=' ')
                print("  dtype ==> %s" % dset.dtype)
                print("Array b read from file. Shape: ==>", b.shape, end=' ')
                print(". Type ==> %s" % b.dtype.char)

            self.assertEqual(a.shape, b.shape)
            if np.dtype('l').itemsize == 4:
                if (a.dtype.char == "i" or a.dtype.char == "l"):
                    # Special expection. We have no way to distinguish between
                    # "l" and "i" typecode, and we can consider them the same
                    # to all practical effects
                    self.assertTrue(b.dtype.char == "l" or b.dtype.char == "i")
                elif (a.dtype.char == "I" or a.dtype.char == "L"):
                    # Special expection. We have no way to distinguish between
                    # "L" and "I" typecode, and we can consider them the same
                    # to all practical effects
                    self.assertTrue(b.dtype.char == "L" or b.dtype.char == "I")
                else:
                    self.assertTrue(allequal(a, b, "numpy"))
            elif np.dtype('l').itemsize == 8:
                if (a.dtype.char == "q" or a.dtype.char == "l"):
                    # Special expection. We have no way to distinguish between
                    # "q" and "l" typecode in 64-bit platforms, and we can
                    # consider them the same to all practical effects
                    self.assertTrue(b.dtype.char == "l" or b.dtype.char == "q")
                elif (a.dtype.char == "Q" or a.dtype.char == "L"):
                    # Special expection. We have no way to distinguish between
                    # "Q" and "L" typecode in 64-bit platforms, and we can
                    # consider them the same to all practical effects
                    self.assertTrue(b.dtype.char == "L" or b.dtype.char == "Q")
                else:
                    self.assertTrue(allequal(a, b, "numpy"))

            # Iterate over the next group
            group = getattr(group, 'group' + str(i))

    def test01_largeRankArrays(self):
        """Checking creation of large rank arrays (0 < rank <= 32)

        It also uses arrays ranks which ranges until maxrank.

        """

        # maximum level of recursivity (deepest group level) achieved:
        # maxrank = 32 (for a effective maximum rank of 32)
        # This limit is due to a limit in the HDF5 library.
        minrank = 1
        maxrank = 32

        if common.verbose:
            print('\n', '-=' * 30)
            print("Running %s.test01_largeRankArrays..." %
                  self.__class__.__name__)
            print("Maximum rank for tested arrays:", maxrank)

        group = self.h5file.root
        if common.verbose:
            print("Rank array writing progress: ", end=' ')
        for rank in range(minrank, maxrank + 1):
            # Create an array of integers, with incrementally bigger ranges
            a = np.ones((1,) * rank, 'i')
            if common.verbose:
                print("%3d," % (rank), end=' ')
            self.h5file.create_array(group, "array", a, "Rank: %s" % rank)
            group = self.h5file.create_group(group, 'group' + str(rank))

        # Flush the buffers
        self.h5file.flush()

        self._reopen()

        group = self.h5file.root
        if common.verbose:
            print()
            print("Rank array reading progress: ")
        # Get the metadata on the previosly saved arrays
        for rank in range(minrank, maxrank + 1):
            # Create an array for later comparison
            a = np.ones((1,) * rank, 'i')
            # Get the actual array
            b = group.array.read()
            if common.verbose:
                print("%3d," % (rank), end=' ')
            if not a.tolist() == b.tolist() and common.verbose:
                dset = group.array
                print("Info from dataset:", dset._v_pathname)
                print("  Shape: ==>", dset.shape, end=' ')
                print("  typecode ==> %c" % dset.typecode)
                print("Array b read from file. Shape: ==>", b.shape, end=' ')
                print(". Type ==> %c" % b.dtype.char)
            self.assertEqual(a.shape, b.shape)
            if a.dtype.char == "i":
                # Special expection. We have no way to distinguish between
                # "l" and "i" typecode, and we can consider them the same
                # to all practical effects
                self.assertTrue(b.dtype.char == "l" or b.dtype.char == "i")
            else:
                self.assertEqual(a.dtype.char, b.dtype.char)

            self.assertEqual(a, b)

            # Iterate over the next group
            group = self.h5file.get_node(group, 'group' + str(rank))

        if common.verbose:
            print()  # This flush the stdout buffer

# Test Record class
class Record(tables.IsDescription):
    var1 = StringCol(itemsize=4, dflt=b"abcd", pos=0)
    var2 = StringCol(itemsize=1, dflt=b"a", pos=1)
    var3 = BoolCol(dflt=1)
    var4 = Int8Col(dflt=1)
    var5 = UInt8Col(dflt=1)
    var6 = Int16Col(dflt=1)
    var7 = UInt16Col(dflt=1)
    var8 = Int32Col(dflt=1)
    var9 = UInt32Col(dflt=1)
    var10 = Int64Col(dflt=1)
    var11 = Float32Col(dflt=1.0)
    var12 = Float64Col(dflt=1.0)
    var13 = ComplexCol(itemsize=8, dflt=(1.+0.j))
    var14 = ComplexCol(itemsize=16, dflt=(1.+0.j))
    if hasattr(tables, 'Float16Col'):
        var15 = tables.Float16Col(dflt=1.0)
    if hasattr(tables, 'Float96Col'):
        var16 = tables.Float96Col(dflt=1.0)
    if hasattr(tables, 'Float128Col'):
        var17 = tables.Float128Col(dflt=1.0)
    if hasattr(tables, 'Complex196Col'):
        var18 = tables.ComplexCol(itemsize=24, dflt=(1.+0.j))
    if hasattr(tables, 'Complex256Col'):
        var19 = tables.ComplexCol(itemsize=32, dflt=(1.+0.j))

class TableReadTestCase(common.TempFileMixin, TestCase):
    nrows = 100

    def setUp(self):
        super(TableReadTestCase, self).setUp()

        # Create an instance of an HDF5 Table
        table = self.h5file.create_table(self.h5file.root, 'table', Record)
        for i in range(self.nrows):
            table.row.append()  # Fill 100 rows with default values

        self._reopen(mode='a')

    def test01_readTableChar(self):
        """Checking column conversion into NumPy in read().

        Char flavor

        """

        table = self.h5file.root.table
        table.flavor = "numpy"
        for colname in table.colnames:
            numcol = table.read(field=colname)
            typecol = table.coltypes[colname]
            itemsizecol = table.description._v_dtypes[colname].base.itemsize
            nctypecode = numcol.dtype.char
            if typecol == "string":
                if itemsizecol > 1:
                    orignumcol = np.array(['abcd']*self.nrows, dtype='S4')
                else:
                    orignumcol = np.array(['a']*self.nrows, dtype='S1')
                if common.verbose:
                    print("Typecode of NumPy column read:", nctypecode)
                    print("Should look like:", 'c')
                    print("Itemsize of column:", itemsizecol)
                    print("Shape of NumPy column read:", numcol.shape)
                    print("Should look like:", orignumcol.shape)
                    print("First 3 elements of read col:", numcol[:3])
                # Check that both NumPy objects are equal
                self.assertTrue(allequal(numcol, orignumcol, "numpy"))

    def test01_readTableNum(self):
        """Checking column conversion into NumPy in read().

        NumPy flavor

        """

        table = self.h5file.root.table
        table.flavor = "numpy"
        for colname in table.colnames:
            numcol = table.read(field=colname)
            typecol = table.coltypes[colname]
            nctypecode = np.typeNA[numcol.dtype.char[0]]
            if typecol != "string":
                if common.verbose:
                    print("Typecode of NumPy column read:", nctypecode)
                    print("Should look like:", typecol)
                orignumcol = np.ones(shape=self.nrows, dtype=numcol.dtype.char)
                # Check that both NumPy objects are equal
                self.assertTrue(allequal(numcol, orignumcol, "numpy"))

    def test02_readCoordsChar(self):
        """Column conversion into NumPy in readCoords().

        Chars

        """

        table = self.h5file.root.table
        table.flavor = "numpy"
        coords = [1, 2, 3]
        self.nrows = len(coords)
        for colname in table.colnames:
            numcol = table.read_coordinates(coords, field=colname)
            typecol = table.coltypes[colname]
            itemsizecol = table.description._v_dtypes[colname].base.itemsize
            nctypecode = numcol.dtype.char
            if typecol == "string":
                if itemsizecol > 1:
                    orignumcol = np.array(['abcd']*self.nrows, dtype='S4')
                else:
                    orignumcol = np.array(['a']*self.nrows, dtype='S1')
                if common.verbose:
                    print("Typecode of NumPy column read:", nctypecode)
                    print("Should look like:", 'c')
                    print("Itemsize of column:", itemsizecol)
                    print("Shape of NumPy column read:", numcol.shape)
                    print("Should look like:", orignumcol.shape)
                    print("First 3 elements of read col:", numcol[:3])
                # Check that both NumPy objects are equal
                self.assertTrue(allequal(numcol, orignumcol, "numpy"))

    def test02_readCoordsNum(self):
        """Column conversion into NumPy in read_coordinates().

        NumPy.

        """

        table = self.h5file.root.table
        table.flavor = "numpy"
        coords = [1, 2, 3]
        self.nrows = len(coords)
        for colname in table.colnames:
            numcol = table.read_coordinates(coords, field=colname)
            typecol = table.coltypes[colname]
            type_ = numcol.dtype.type
            if typecol != "string":
                if typecol == "int64":
                    return
                if common.verbose:
                    print("Type of read NumPy column:", type_)
                    print("Should look like:", typecol)
                orignumcol = np.ones(shape=self.nrows, dtype=numcol.dtype.char)
                # Check that both NumPy objects are equal
                self.assertTrue(allequal(numcol, orignumcol, "numpy"))

    def test03_getIndexNumPy(self):
        """Getting table rows specifyied as NumPy scalar integers."""

        table = self.h5file.root.table
        coords = np.array([1, 2, 3], dtype='int8')
        for colname in table.colnames:
            numcol = [table[coord][colname] for coord in coords]
            typecol = table.coltypes[colname]
            if typecol != "string":
                if typecol == "int64":
                    return
                numcol = np.array(numcol, typecol)
                if common.verbose:
                    type_ = numcol.dtype.type
                    print("Type of read NumPy column:", type_)
                    print("Should look like:", typecol)
                orignumcol = np.ones(shape=len(numcol),
                                     dtype=numcol.dtype.char)
                # Check that both NumPy objects are equal
                self.assertTrue(allequal(numcol, orignumcol, "numpy"))

    def test04_setIndexNumPy(self):
        """Setting table rows specifyied as NumPy integers."""

        self._reopen(mode='a')
        table = self.h5file.root.table
        table.flavor = "numpy"
        coords = np.array([1, 2, 3], dtype='int8')
        # Modify row 1
        # From PyTables 2.0 on, assignments to records can be done
        # only as tuples (see http://projects.scipy.org/scipy/numpy/ticket/315)
        # table[coords[0]] = ["aasa","x"]+[232]*12

        n = len(Record.columns) - 2

        table[coords[0]] = tuple(["aasa", "x"]+[232]*n)     # XXX
        # record = list(table[coords[0]])
        record = table.read(coords[0], coords[0] + 1)
        if common.verbose:
            print("Original row:\n"
                  "['aasa', 'x', True, -24, 232, 232, 232, 232, 232L, "
                  "232, 232.0, 232.0, (232 + 0j), (232+0j), 232.0, "
                  "(232+0j)]\n")
            print("Read row:\n", record)
        self.assertEqual(record['var1'], b'aasa')
        self.assertEqual(record['var2'], b'x')
        self.assertEqual(record['var3'], True)
        self.assertEqual(record['var4'], -24)
        self.assertEqual(record['var7'], 232)

# The declaration of the nested table:
class Info(tables.IsDescription):
    _v_pos = 3
    Name = StringCol(itemsize=2)
    Value = ComplexCol(itemsize=16)

class TestTDescr(tables.IsDescription):

    """A description that has several nested columns."""

    x = Int32Col(dflt=0, shape=2, pos=0)  # 0
    y = FloatCol(dflt=1, shape=(2, 2))
    z = UInt8Col(dflt=1)
    z3 = EnumCol({'r': 4, 'g': 2, 'b': 1}, 'r', 'int32', shape=2)
    color = StringCol(itemsize=4, dflt=b"ab", pos=2)
    info = Info()

    class Info(tables.IsDescription):  # 1
        _v_pos = 1
        name = StringCol(itemsize=2)
        value = ComplexCol(itemsize=16, pos=0)  # 0
        y2 = FloatCol(pos=1)  # 1
        z2 = UInt8Col()

        class Info2(tables.IsDescription):
            y3 = Time64Col(shape=2)
            name = StringCol(itemsize=2)
            value = ComplexCol(itemsize=16, shape=2)

class TableNativeFlavorTestCase(common.TempFileMixin, TestCase):
    nrows = 100

    def setUp(self):
        super(TableNativeFlavorTestCase, self).setUp()

        # Create an instance of an HDF5 Table
        table = self.h5file.create_table(self.h5file.root, 'table', TestTDescr,
                                         expectedrows=self.nrows)
        table.flavor = "numpy"
        for i in range(self.nrows):
            table.row.append()  # Fill 100 rows with default values
        table.flush()

    def test01a_basicTableRead(self):
        """Checking the return of a NumPy in read()."""

        if self.close:
            self._reopen(mode='a')
        table = self.h5file.root.table
        data = table[:]
        if common.verbose:
            print("Type of read:", type(data))
            print("Description of the record:", data.dtype.descr)
            print("First 3 elements of read:", data[:3])

        # Check that both NumPy objects are equal
        self.assertTrue(isinstance(data, np.ndarray))

        # Check the value of some columns
        # A flat column
        col = table.cols.x[:3]
        self.assertTrue(isinstance(col, np.ndarray))
        npcol = np.zeros((3, 2), dtype="int32")
        self.assertTrue(allequal(col, npcol, "numpy"))

        # A nested column
        col = table.cols.Info[:3]
        self.assertTrue(isinstance(col, np.ndarray))
        dtype = [('value', 'c16'),
                 ('y2', 'f8'),
                 ('Info2',
                  [('name', 'S2'),
                   ('value', 'c16', (2,)),
                   ('y3', 'f8', (2,))]),
                 ('name', 'S2'),
                 ('z2', 'u1')]
        npcol = np.zeros((3,), dtype=dtype)
        self.assertEqual(col.dtype.descr, npcol.dtype.descr)
        if common.verbose:
            print("col-->", col)
            print("npcol-->", npcol)

        # A copy() is needed in case the buffer can be in different segments
        self.assertEqual(bytes(col.copy().data), bytes(npcol.data))

    def test01b_basicTableRead(self):
        """Checking the return of a NumPy in read() (strided version)."""

        if self.close:
            self._reopen(mode='a')
        table = self.h5file.root.table
        data = table[::3]
        if common.verbose:
            print("Type of read:", type(data))
            print("Description of the record:", data.dtype.descr)
            print("First 3 elements of read:", data[:3])

        # Check that both NumPy objects are equal
        self.assertTrue(isinstance(data, np.ndarray))

        # Check the value of some columns
        # A flat column
        col = table.cols.x[:9:3]
        self.assertTrue(isinstance(col, np.ndarray))
        npcol = np.zeros((3, 2), dtype="int32")
        self.assertTrue(allequal(col, npcol, "numpy"))

        # A nested column
        col = table.cols.Info[:9:3]
        self.assertTrue(isinstance(col, np.ndarray))
        dtype = [('value', '%sc16' % byteorder),
                 ('y2', '%sf8' % byteorder),
                 ('Info2',
                  [('name', '|S2'),
                   ('value', '%sc16' % byteorder, (2,)),
                   ('y3', '%sf8' % byteorder, (2,))]),
                 ('name', '|S2'),
                 ('z2', '|u1')]
        npcol = np.zeros((3,), dtype=dtype)
        self.assertEqual(col.dtype.descr, npcol.dtype.descr)
        if common.verbose:
            print("col-->", col)
            print("npcol-->", npcol)

        # A copy() is needed in case the buffer can be in different segments
        self.assertEqual(bytes(col.copy().data), bytes(npcol.data))

    def test02_getWhereList(self):
        """Checking the return of NumPy in get_where_list method."""

        if self.close:
            self._reopen(mode='a')
        table = self.h5file.root.table
        data = table.get_where_list('z == 1')
        if common.verbose:
            print("Type of read:", type(data))
            print("Description of the record:", data.dtype.descr)
            print("First 3 elements of read:", data[:3])

        # Check that both NumPy objects are equal
        self.assertTrue(isinstance(data, np.ndarray))

        # Check that all columns have been selected
        self.assertEqual(len(data), 100)

        # Finally, check that the contents are ok
        self.assertTrue(allequal(data, np.arange(100, dtype="i8"), "numpy"))

    def test03a_readWhere(self):
        """Checking the return of NumPy in read_where method (strings)."""

        table = self.h5file.root.table
        table.cols.color.create_index()
        if self.close:
            self._reopen(mode='a')
            table = self.h5file.root.table
        data = table.read_where('color == b"ab"')
        if common.verbose:
            print("Type of read:", type(data))
            print("Length of the data read:", len(data))

        # Check that both NumPy objects are equal
        self.assertTrue(isinstance(data, np.ndarray))

        # Check that all columns have been selected
        self.assertEqual(len(data), self.nrows)

    def test03b_readWhere(self):
        """Checking the return of NumPy in read_where method (numeric)."""

        table = self.h5file.root.table
        table.cols.z.create_index()
        if self.close:
            self._reopen(mode='a')
            table = self.h5file.root.table
        data = table.read_where('z == 0')
        if common.verbose:
            print("Type of read:", type(data))
            print("Length of the data read:", len(data))

        # Check that both NumPy objects are equal
        self.assertTrue(isinstance(data, np.ndarray))

        # Check that all columns have been selected
        self.assertEqual(len(data), 0)

    def test04a_createTable(self):
        """Checking the Table creation from a numpy recarray."""

        dtype = [('value', '%sc16' % byteorder),
                 ('y2', '%sf8' % byteorder),
                 ('Info2',
                  [('name', '|S2'),
                   ('value', '%sc16' % byteorder, (2,)),
                   ('y3', '%sf8' % byteorder, (2,))]),
                 ('name', '|S2'),
                 ('z2', '|u1')]
        npdata = np.zeros((3,), dtype=dtype)
        table = self.h5file.create_table(self.h5file.root, 'table2', npdata)
        if self.close:
            self._reopen(mode='a')
            table = self.h5file.root.table2
        data = table[:]
        if common.verbose:
            print("Type of read:", type(data))
            print("Description of the record:", data.dtype.descr)
            print("First 3 elements of read:", data[:3])
            print("Length of the data read:", len(data))

        # Check that both NumPy objects are equal
        self.assertTrue(isinstance(data, np.ndarray))

        # Check the type
        self.assertEqual(data.dtype.descr, npdata.dtype.descr)
        if common.verbose:
            print("npdata-->", npdata)
            print("data-->", data)

        # A copy() is needed in case the buffer would be in different segments
        self.assertEqual(bytes(data.copy().data), bytes(npdata.data))

    def test04b_appendTable(self):
        """Checking appending a numpy recarray."""

        table = self.h5file.root.table
        npdata = table[3:6]
        table.append(npdata)
        if self.close:
            self._reopen(mode='a')
            table = self.h5file.root.table
        data = table[-3:]
        if common.verbose:
            print("Type of read:", type(data))
            print("Description of the record:", data.dtype.descr)
            print("Last 3 elements of read:", data[-3:])
            print("Length of the data read:", len(data))

        # Check that both NumPy objects are equal
        self.assertTrue(isinstance(data, np.ndarray))

        # Check the type
        self.assertEqual(data.dtype.descr, npdata.dtype.descr)
        if common.verbose:
            print("npdata-->", npdata)
            print("data-->", data)

        # A copy() is needed in case the buffer would be in different segments
        self.assertEqual(bytes(data.copy().data), bytes(npdata.data))

    def test05a_assignColumn(self):
        """Checking assigning to a column."""

        table = self.h5file.root.table
        table.cols.z[:] = np.zeros((100,), dtype='u1')
        if self.close:
            self._reopen(mode='a')
            table = self.h5file.root.table
        data = table.cols.z[:]
        if common.verbose:
            print("Type of read:", type(data))
            print("Description of the record:", data.dtype.descr)
            print("First 3 elements of read:", data[:3])
            print("Length of the data read:", len(data))

        # Check that both NumPy objects are equal
        self.assertTrue(isinstance(data, np.ndarray))

        # Check that all columns have been selected
        self.assertEqual(len(data), 100)

        # Finally, check that the contents are ok
        self.assertTrue(allequal(data, np.zeros((100,), dtype="u1"), "numpy"))

    def test05b_modifyingColumns(self):
        """Checking modifying several columns at once."""

        table = self.h5file.root.table
        xcol = np.ones((3, 2), 'int32')
        ycol = np.zeros((3, 2, 2), 'float64')
        zcol = np.zeros((3,), 'uint8')
        table.modify_columns(3, 6, 1, [xcol, ycol, zcol], ['x', 'y', 'z'])
        if self.close:
            self._reopen(mode='a')
            table = self.h5file.root.table
        data = table.cols.y[3:6]
        if common.verbose:
            print("Type of read:", type(data))
            print("Description of the record:", data.dtype.descr)
            print("First 3 elements of read:", data[:3])
            print("Length of the data read:", len(data))

        # Check that both NumPy objects are equal
        self.assertTrue(isinstance(data, np.ndarray))

        # Check the type
        self.assertEqual(data.dtype.descr, ycol.dtype.descr)
        if common.verbose:
            print("ycol-->", ycol)
            print("data-->", data)

        # A copy() is needed in case the buffer would be in different segments
        self.assertEqual(data.copy().data, ycol.data)

    def test05c_modifyingColumns(self):
        """Checking modifying several columns using a single numpy buffer."""

        table = self.h5file.root.table
        dtype = [('x', 'i4', (2,)), ('y', 'f8', (2, 2)), ('z', 'u1')]
        nparray = np.zeros((3,), dtype=dtype)
        table.modify_columns(3, 6, 1, nparray, ['x', 'y', 'z'])
        if self.close:
            self._reopen(mode='a')
            table = self.h5file.root.table
        ycol = np.zeros((3, 2, 2), 'float64')
        data = table.cols.y[3:6]
        if common.verbose:
            print("Type of read:", type(data))
            print("Description of the record:", data.dtype.descr)
            print("First 3 elements of read:", data[:3])
            print("Length of the data read:", len(data))

        # Check that both NumPy objects are equal
        self.assertTrue(isinstance(data, np.ndarray))

        # Check the type
        self.assertEqual(data.dtype.descr, ycol.dtype.descr)
        if common.verbose:
            print("ycol-->", ycol)
            print("data-->", data)

        # A copy() is needed in case the buffer would be in different segments
        self.assertEqual(data.copy().data, ycol.data)

    def test06a_assignNestedColumn(self):
        """Checking assigning a nested column (using modify_column)."""

        table = self.h5file.root.table
        dtype = [('value', '%sc16' % byteorder),
                 ('y2', '%sf8' % byteorder),
                 ('Info2',
                  [('name', '|S2'),
                   ('value', '%sc16' % byteorder, (2,)),
                   ('y3', '%sf8' % byteorder, (2,))]),
                 ('name', '|S2'),
                 ('z2', '|u1')]
        npdata = np.zeros((3,), dtype=dtype)
        data = table.cols.Info[3:6]
        table.modify_column(3, 6, 1, column=npdata, colname='Info')
        if self.close:
            self._reopen(mode='a')
            table = self.h5file.root.table
        data = table.cols.Info[3:6]
        if common.verbose:
            print("Type of read:", type(data))
            print("Description of the record:", data.dtype.descr)
            print("First 3 elements of read:", data[:3])
            print("Length of the data read:", len(data))

        # Check that both NumPy objects are equal
        self.assertTrue(isinstance(data, np.ndarray))

        # Check the type
        self.assertEqual(data.dtype.descr, npdata.dtype.descr)
        if common.verbose:
            print("npdata-->", npdata)
            print("data-->", data)

        # A copy() is needed in case the buffer would be in different segments
        self.assertEqual(bytes(data.copy().data), bytes(npdata.data))

    def test06b_assignNestedColumn(self):
        """Checking assigning a nested column (using the .cols accessor)."""

        table = self.h5file.root.table
        dtype = [('value', '%sc16' % byteorder),
                 ('y2', '%sf8' % byteorder),
                 ('Info2',
                  [('name', '|S2'),
                   ('value', '%sc16' % byteorder, (2,)),
                   ('y3', '%sf8' % byteorder, (2,))]),
                 ('name', '|S2'),
                 ('z2', '|u1')]
        npdata = np.zeros((3,), dtype=dtype)
        #self.assertRaises(NotImplementedError,
        #                  table.cols.Info.__setitem__, slice(3,6,1),  npdata)
        table.cols.Info[3:6] = npdata
        if self.close:
            self._reopen(mode='a')
            table = self.h5file.root.table
        data = table.cols.Info[3:6]
        if common.verbose:
            print("Type of read:", type(data))
            print("Description of the record:", data.dtype.descr)
            print("First 3 elements of read:", data[:3])
            print("Length of the data read:", len(data))

        # Check that both NumPy objects are equal
        self.assertTrue(isinstance(data, np.ndarray))

        # Check the type
        self.assertEqual(data.dtype.descr, npdata.dtype.descr)
        if common.verbose:
            print("npdata-->", npdata)
            print("data-->", data)

        # A copy() is needed in case the buffer would be in different segments
        self.assertEqual(bytes(data.copy().data), bytes(npdata.data))

    def test07a_modifyingRows(self):
        """Checking modifying several rows at once (using modify_rows)."""

        table = self.h5file.root.table

        # Read a chunk of the table
        chunk = table[0:3]

        # Modify it somewhat
        chunk['y'][:] = -1
        table.modify_rows(3, 6, 1, rows=chunk)
        if self.close:
            self._reopen(mode='a')
            table = self.h5file.root.table
        ycol = np.zeros((3, 2, 2), 'float64')-1
        data = table.cols.y[3:6]
        if common.verbose:
            print("Type of read:", type(data))
            print("Description of the record:", data.dtype.descr)
            print("First 3 elements of read:", data[:3])
            print("Length of the data read:", len(data))

        # Check that both NumPy objects are equal
        self.assertTrue(isinstance(data, np.ndarray))

        # Check the type
        self.assertEqual(data.dtype.descr, ycol.dtype.descr)
        if common.verbose:
            print("ycol-->", ycol)
            print("data-->", data)
        self.assertTrue(allequal(ycol, data, "numpy"))

    def test07b_modifyingRows(self):
        """Checking modifying several rows at once (using cols accessor)."""

        table = self.h5file.root.table

        # Read a chunk of the table
        chunk = table[0:3]

        # Modify it somewhat
        chunk['y'][:] = -1
        table.cols[3:6] = chunk
        if self.close:
            self._reopen(mode='a')
            table = self.h5file.root.table

        # Check that some column has been actually modified
        ycol = np.zeros((3, 2, 2), 'float64')-1
        data = table.cols.y[3:6]
        if common.verbose:
            print("Type of read:", type(data))
            print("Description of the record:", data.dtype.descr)
            print("First 3 elements of read:", data[:3])
            print("Length of the data read:", len(data))

        # Check that both NumPy objects are equal
        self.assertTrue(isinstance(data, np.ndarray))

        # Check the type
        self.assertEqual(data.dtype.descr, ycol.dtype.descr)
        if common.verbose:
            print("ycol-->", ycol)
            print("data-->", data)
        self.assertTrue(allequal(ycol, data, "numpy"))

    def test08a_modifyingRows(self):
        """Checking modifying just one row at once (using modify_rows)."""

        table = self.h5file.root.table

        # Read a chunk of the table
        chunk = table[3:4]

        # Modify it somewhat
        chunk['y'][:] = -1
        table.modify_rows(6, 7, 1, chunk)
        if self.close:
            self._reopen(mode='a')
            table = self.h5file.root.table

        # Check that some column has been actually modified
        ycol = np.zeros((2, 2), 'float64')-1
        data = table.cols.y[6]
        if common.verbose:
            print("Type of read:", type(data))
            print("Description of the record:", data.dtype.descr)
            print("First 3 elements of read:", data[:3])
            print("Length of the data read:", len(data))

        # Check that both NumPy objects are equal
        self.assertTrue(isinstance(data, np.ndarray))

        # Check the type
        self.assertEqual(data.dtype.descr, ycol.dtype.descr)
        if common.verbose:
            print("ycol-->", ycol)
            print("data-->", data)
        self.assertTrue(allequal(ycol, data, "numpy"))

    def test08b_modifyingRows(self):
        """Checking modifying just one row at once (using cols accessor)."""

        table = self.h5file.root.table

        # Read a chunk of the table
        chunk = table[3:4]

        # Modify it somewhat
        chunk['y'][:] = -1
        table.cols[6] = chunk
        if self.close:
            self._reopen(mode='a')
            table = self.h5file.root.table

        # Check that some column has been actually modified
        ycol = np.zeros((2, 2), 'float64')-1
        data = table.cols.y[6]
        if common.verbose:
            print("Type of read:", type(data))
            print("Description of the record:", data.dtype.descr)
            print("First 3 elements of read:", data[:3])
            print("Length of the data read:", len(data))

        # Check that both NumPy objects are equal
        self.assertTrue(isinstance(data, np.ndarray))

        # Check the type
        self.assertEqual(data.dtype.descr, ycol.dtype.descr)
        if common.verbose:
            print("ycol-->", ycol)
            print("data-->", data)
        self.assertTrue(allequal(ycol, data, "numpy"))

    def test09a_getStrings(self):
        """Checking the return of string columns with spaces."""

        if self.close:
            self._reopen(mode='a')
        table = self.h5file.root.table
        rdata = table.get_where_list('color == b"ab"')
        data = table.read_coordinates(rdata)
        if common.verbose:
            print("Type of read:", type(data))
            print("Description of the record:", data.dtype.descr)
            print("First 3 elements of read:", data[:3])

        # Check that both NumPy objects are equal
        self.assertTrue(isinstance(data, np.ndarray))

        # Check that all columns have been selected
        self.assertEqual(len(data), 100)

        # Finally, check that the contents are ok
        for idata in data['color']:
            self.assertEqual(idata, np.array("ab", dtype="|S4"))

    def test09b_getStrings(self):
        """Checking the return of string columns with spaces.

        (modify)

        """

        if self.close:
            self._reopen(mode='a')
        table = self.h5file.root.table
        for i in range(50):
            table.cols.color[i] = "a  "
        table.flush()
        data = table[:]
        if common.verbose:
            print("Type of read:", type(data))
            print("Description of the record:", data.dtype.descr)
            print("First 3 elements of read:", data[:3])

        # Check that both NumPy objects are equal
        self.assertTrue(isinstance(data, np.ndarray))

        # Check that all columns have been selected
        self.assertEqual(len(data), 100)

        # Finally, check that the contents are ok
        for i in range(100):
            idata = data['color'][i]
            if i >= 50:
                self.assertEqual(idata, np.array("ab", dtype="|S4"))
            else:
                self.assertEqual(idata, np.array("a  ", dtype="|S4"))

    def test09c_getStrings(self):
        """Checking the return of string columns with spaces.

        (append)

        """

        if self.close:
            self._reopen(mode='a')
        table = self.h5file.root.table
        row = table.row
        for i in range(50):
            row["color"] = "a  "   # note the trailing spaces
            row.append()
        table.flush()
        if self.close:
            self.h5file.close()
            self.h5file = tables.open_file(self.h5fname, "a")
        data = self.h5file.root.table[:]
        if common.verbose:
            print("Type of read:", type(data))
            print("Description of the record:", data.dtype.descr)
            print("First 3 elements of read:", data[:3])

        # Check that both NumPy objects are equal
        self.assertTrue(isinstance(data, np.ndarray))

        # Check that all columns have been selected
        self.assertEqual(len(data), 150)

        # Finally, check that the contents are ok
        for i in range(150):
            idata = data['color'][i]
            if i < 100:
                self.assertEqual(idata, np.array("ab", dtype="|S4"))
            else:
                self.assertEqual(idata, np.array("a  ", dtype="|S4"))

class TableNativeFlavorOpenTestCase(TableNativeFlavorTestCase):
    close = 0

class TableNativeFlavorCloseTestCase(TableNativeFlavorTestCase):
    close = 1

class AttributesTestCase(common.TempFileMixin, TestCase):
    def setUp(self):
        super(AttributesTestCase, self).setUp()

        # Create an instance of an HDF5 Table
        self.h5file.create_group(self.h5file.root, 'group')

    def test01_writeAttribute(self):
        """Checking the creation of a numpy attribute."""

        group = self.h5file.root.group
        g_attrs = group._v_attrs
        g_attrs.numpy1 = np.zeros((1, 1), dtype='int16')
        if self.close:
            self._reopen(mode='a')
            group = self.h5file.root.group
            g_attrs = group._v_attrs

        # Check that we can retrieve a numpy object
        data = g_attrs.numpy1
        npcomp = np.zeros((1, 1), dtype='int16')

        # Check that both NumPy objects are equal
        self.assertTrue(isinstance(data, np.ndarray))

        # Check the type
        self.assertEqual(data.dtype.descr, npcomp.dtype.descr)
        if common.verbose:
            print("npcomp-->", npcomp)
            print("data-->", data)
        self.assertTrue(allequal(npcomp, data, "numpy"))

    def test02_updateAttribute(self):
        """Checking the modification of a numpy attribute."""

        group = self.h5file.root.group
        g_attrs = group._v_attrs
        g_attrs.numpy1 = np.zeros((1, 2), dtype='int16')
        if self.close:
            self._reopen(mode='a')
            group = self.h5file.root.group
            g_attrs = group._v_attrs

        # Update this attribute
        g_attrs.numpy1 = np.ones((1, 2), dtype='int16')

        # Check that we can retrieve a numpy object
        data = g_attrs.numpy1
        npcomp = np.ones((1, 2), dtype='int16')

        # Check that both NumPy objects are equal
        self.assertTrue(isinstance(data, np.ndarray))

        # Check the type
        self.assertEqual(data.dtype.descr, npcomp.dtype.descr)
        if common.verbose:
            print("npcomp-->", npcomp)
            print("data-->", data)
        self.assertTrue(allequal(npcomp, data, "numpy"))

class AttributesOpenTestCase(AttributesTestCase):
    close = 0

class AttributesCloseTestCase(AttributesTestCase):
    close = 1

class StrlenTestCase(common.TempFileMixin, TestCase):
    def setUp(self):
        super(StrlenTestCase, self).setUp()

        # Create an instance of an HDF5 Table
        group = self.h5file.create_group(self.h5file.root, 'group')
        tablelayout = {'Text': StringCol(itemsize=1000), }
        self.table = self.h5file.create_table(group, 'table', tablelayout)
        self.table.flavor = 'numpy'
        row = self.table.row
        row['Text'] = 'Hello Francesc!'     # XXX: check unicode --> bytes
        row.append()
        row['Text'] = 'Hola Francesc!'      # XXX: check unicode --> bytes
        row.append()
        self.table.flush()

    def test01(self):
        """Checking the lengths of strings (read field)."""

        if self.close:
            self._reopen(mode='a')
            self.table = self.h5file.root.group.table

        # Get both strings
        str1 = self.table.col('Text')[0]
        str2 = self.table.col('Text')[1]
        if common.verbose:
            print("string1-->", str1)
            print("string2-->", str2)

        # Check that both NumPy objects are equal
        self.assertEqual(len(str1), len(b'Hello Francesc!'))
        self.assertEqual(len(str2), len(b'Hola Francesc!'))
        self.assertEqual(str1, b'Hello Francesc!')
        self.assertEqual(str2, b'Hola Francesc!')

    def test02(self):
        """Checking the lengths of strings (read recarray)."""

        if self.close:
            self._reopen(mode='a')
            self.table = self.h5file.root.group.table

        # Get both strings
        str1 = self.table[:]['Text'][0]
        str2 = self.table[:]['Text'][1]

        # Check that both NumPy objects are equal
        self.assertEqual(len(str1), len(b'Hello Francesc!'))
        self.assertEqual(len(str2), len(b'Hola Francesc!'))
        self.assertEqual(str1, b'Hello Francesc!')
        self.assertEqual(str2, b'Hola Francesc!')

    def test03(self):
        """Checking the lengths of strings (read recarray, row by row)."""

        if self.close:
            self._reopen(mode='a')
            self.table = self.h5file.root.group.table

        # Get both strings
        str1 = self.table[0]['Text']
        str2 = self.table[1]['Text']

        # Check that both NumPy objects are equal
        self.assertEqual(len(str1), len(b'Hello Francesc!'))
        self.assertEqual(len(str2), len(b'Hola Francesc!'))
        self.assertEqual(str1, b'Hello Francesc!')
        self.assertEqual(str2, b'Hola Francesc!')

class StrlenOpenTestCase(StrlenTestCase):
    close = 0

class StrlenCloseTestCase(StrlenTestCase):
    close = 1

def suite():
    theSuite = unittest.TestSuite()
    niter = 1

    # theSuite.addTest(unittest.makeSuite(StrlenOpenTestCase))
    # theSuite.addTest(unittest.makeSuite(Basic0DOneTestCase))
    # theSuite.addTest(unittest.makeSuite(GroupsArrayTestCase))
    for i in range(niter):
        theSuite.addTest(unittest.makeSuite(Basic0DOneTestCase))
        theSuite.addTest(unittest.makeSuite(Basic0DTwoTestCase))
        theSuite.addTest(unittest.makeSuite(Basic1DOneTestCase))
        theSuite.addTest(unittest.makeSuite(Basic1DTwoTestCase))
        theSuite.addTest(unittest.makeSuite(Basic1DThreeTestCase))
        theSuite.addTest(unittest.makeSuite(Basic2DTestCase))
        theSuite.addTest(unittest.makeSuite(GroupsArrayTestCase))
        theSuite.addTest(unittest.makeSuite(TableReadTestCase))
        theSuite.addTest(unittest.makeSuite(TableNativeFlavorOpenTestCase))
        theSuite.addTest(unittest.makeSuite(TableNativeFlavorCloseTestCase))
        theSuite.addTest(unittest.makeSuite(AttributesOpenTestCase))
        theSuite.addTest(unittest.makeSuite(AttributesCloseTestCase))
        theSuite.addTest(unittest.makeSuite(StrlenOpenTestCase))
        theSuite.addTest(unittest.makeSuite(StrlenCloseTestCase))
        if common.heavy:
            theSuite.addTest(unittest.makeSuite(Basic10DTestCase))
            # The 32 dimensions case takes forever to run!!
            # theSuite.addTest(unittest.makeSuite(Basic32DTestCase))
    return theSuite

if __name__ == '__main__':
    common.parse_argv(sys.argv)
    common.print_versions()
    unittest.main(defaultTest='suite')


text:
- Original: [Release electron v14.0.0-beta.5 - electron/electron](https://github.com/electron/electron/releases/tag/v14.0.0-beta.5)

Note: This is a beta release. Please file new issues for any bugs you find in it.

This release is published to npm under the beta tag and can be installed via `npm install electron@beta`, or `npm install electron@14.0.0-beta.5`.

> Note: これはベータ リリースです。なにかバグを見つけた場合は issue 報告してください。
>
> 本リリースは `beta` タグの [npm](https://www.npmjs.com/package/electron) として公開しており `npm install electron@beta` または `npm i electron@14.0.0-beta.5` でインストールできます。

## Fixes

- Fixed memory leak when requesting files in ASAR archive from renderer. [#29536](https://github.com/electron/electron/pull/29536) (Also in [12](https://github.com/electron/electron/pull/29548), [13](https://github.com/electron/electron/pull/29535))
  - Renderer (プロセス) から ASAR アーカイブ内のファイルをリクエストした際のメモリー リークを修正しました
  - ASAR キャッシュをスレッド ローカルからプロセス全体とすることで修正
- Electron Fuses are now in a consistent order across platforms. [#29616](https://github.com/electron/electron/pull/29616) (Also in [13](https://github.com/electron/electron/pull/29615))
  - Electron Fuses の並び順をすべてのプラットフォームで統一しました
  - Electron をビルドする Python 処理系 (2 と 3) で辞書順の解釈が異なるため `OrderedDict` を指定して明示的に順番統一されるようにしたとのこと
- Fixed an issue where `fs.promises.readFile` would improperly error when passing a `FileHandle` to the `path` argument. [#29577](https://github.com/electron/electron/pull/29577) (Also in [13](https://github.com/electron/electron/pull/29576))
  - `FileHandle` を引数 `path` へ渡す際に `fs.promises.readFile` で不適切なエラーが発生する問題を修正しました
  - `fs.readFile` を `Promise` 化する処理に起因する問題を修正
- Fixed sending intermediate certificates with 'select-client-certificate' event callback. [#29570](https://github.com/electron/electron/pull/29570) (Also in [12](https://github.com/electron/electron/pull/29568), [13](https://github.com/electron/electron/pull/29569))
  - 'select-client-certificate' イベントのコールバックによる中間証明書の送信を修正しました
  - 不完全な証明書チェーンが送信される問題 [#28553](https://github.com/electron/electron/issues/28553) を修正

## Other Changes

- Updated Chromium to 93.0.4536.0. [#29617](https://github.com/electron/electron/pull/29617)
  - Chromium を 93.0.4536.0 へ更新しました
  - 変更点は[こちら](https://chromium.googlesource.com/chromium/src/+log/93.0.4535.0..93.0.4536.0?n=10000&pretty=fuller)を参照のこと

redpajama_set_name: RedPajamaGithub


text:
using System;
using System.Linq;
using System.Threading;
using BenchmarkDotNet.Attributes;
using BenchmarkDotNet.Configs;
using BenchmarkDotNet.Jobs;

namespace BenchmarkDotNet.Samples.Intro
{
    [MyConfigSource(Jit.LegacyJit, Jit.RyuJit)]
    public class IntroConfigSource
    {
        /// <summary>
        /// Dry-x64 jobs for specific jits
        /// </summary>
        private class MyConfigSourceAttribute : Attribute, IConfigSource
        {
            public IConfig Config { get; private set; }

            public MyConfigSourceAttribute(params Jit[] jits)
            {
                var jobs = jits.Select(jit => Job.Dry.With(Platform.X64).With(jit)).ToArray();
                Config = ManualConfig.CreateEmpty().With(jobs);
            }
        }

        [Benchmark]
        public void Foo()
        {
            Thread.Sleep(10);
        }
    }
}


text:
using namespace content;

namespace ash {

KeyboardControllerProxyStub::KeyboardControllerProxyStub()
    : keyboard::KeyboardControllerProxy(Shell::GetInstance()
                                            ->delegate()
                                            ->GetActiveBrowserContext()) {
}

KeyboardControllerProxyStub::~KeyboardControllerProxyStub() {
}

bool KeyboardControllerProxyStub::HasKeyboardWindow() const {
  return keyboard_;
}

aura::Window* KeyboardControllerProxyStub::GetKeyboardWindow() {
  if (!keyboard_) {
    keyboard_.reset(new aura::Window(&delegate_));
    keyboard_->Init(ui::LAYER_NOT_DRAWN);
  }
  return keyboard_.get();
}

ui::InputMethod* KeyboardControllerProxyStub::GetInputMethod() {
  aura::Window* active_window = wm::GetActiveWindow();
  aura::Window* root_window = active_window ? active_window->GetRootWindow()
                                            : Shell::GetPrimaryRootWindow();
  return root_window->GetHost()->GetInputMethod();
}

void KeyboardControllerProxyStub::RequestAudioInput(
    WebContents* web_contents,
    const MediaStreamRequest& request,
    const MediaResponseCallback& callback) {
}

void KeyboardControllerProxyStub::LoadSystemKeyboard() {
}

void KeyboardControllerProxyStub::ReloadKeyboardIfNeeded() {
}

}  // namespace ash


text:
        How-to

      Getting started

      Data modeling

      Migrate from

Tutorials

        BUCKETIZE
        REDUCE

      Pushing data

        Using WebSockets
        Using metrics collecting tools

      Accessing data

      Fetching data

      Create and deploy one User Defined Function

      Create a WarpScript extension

      Connect Warp 10 to Apache Zeppelin

      Monitoring Warp 10


text:
var redis = require("./index"),
    metrics = require("metrics"),
    num_clients = parseInt(process.argv[2], 10) || 5,
    num_requests = 20000,
    tests = [],
    versions_logged = false,
    client_options = {
        return_buffers: false
    },
    small_str, large_str, small_buf, large_buf;

redis.debug_mode = false;

function lpad(input, len, chr) {
    var str = input.toString();
    chr = chr || " ";

    while (str.length < len) {
        str = chr + str;
    }
    return str;
}

metrics.Histogram.prototype.print_line = function () {
    var obj = this.printObj();

    return lpad(obj.min, 4) + "/" + lpad(obj.max, 4) + "/" + lpad(obj.mean.toFixed(2), 7) + "/" + lpad(obj.p95.toFixed(2), 7);
};

function Test(args) {
    var self = this;

    this.args = args;

    this.callback = null;
    this.clients = [];
    this.clients_ready = 0;
    this.commands_sent = 0;
    this.commands_completed = 0;
    this.max_pipeline = this.args.pipeline || num_requests;
    this.client_options = args.client_options || client_options;

    this.connect_latency = new metrics.Histogram();
    this.ready_latency = new metrics.Histogram();
    this.command_latency = new metrics.Histogram();
}

Test.prototype.run = function (callback) {
    var self = this, i;

    this.callback = callback;

    for (i = 0; i < num_clients ; i++) {
        this.new_client(i);
    }
};

Test.prototype.new_client = function (id) {
    var self = this, new_client;

    new_client = redis.createClient(6379, "127.0.0.1", this.client_options);
    new_client.create_time = Date.now();

    new_client.on("connect", function () {
        self.connect_latency.update(Date.now() - new_client.create_time);
    });

    new_client.on("ready", function () {
        if (! versions_logged) {
            console.log("Client count: " + num_clients + ", node version: " + process.versions.node + ", server version: " +
                new_client.server_info.redis_version + ", parser: " + new_client.reply_parser.name);
            versions_logged = true;
        }
        self.ready_latency.update(Date.now() - new_client.create_time);
        self.clients_ready++;
        if (self.clients_ready === self.clients.length) {
            self.on_clients_ready();
        }
    });

    self.clients[id] = new_client;
};

Test.prototype.on_clients_ready = function () {
    process.stdout.write(lpad(this.args.descr, 13) + ", " + lpad(this.args.pipeline, 5) + "/" + this.clients_ready + " ");
    this.test_start = Date.now();

    this.fill_pipeline();
};

Test.prototype.fill_pipeline = function () {
    var pipeline = this.commands_sent - this.commands_completed;

    while (this.commands_sent < num_requests && pipeline < this.max_pipeline) {
        this.commands_sent++;
        pipeline++;
        this.send_next();
    }

    if (this.commands_completed === num_requests) {
        this.print_stats();
        this.stop_clients();
    }
};

Test.prototype.stop_clients = function () {
    var self = this;

    this.clients.forEach(function (client, pos) {
        if (pos === self.clients.length - 1) {
            client.quit(function (err, res) {
                self.callback();
            });
        } else {
            client.quit();
        }
    });
};

Test.prototype.send_next = function () {
    var self = this,
        cur_client = this.commands_sent % this.clients.length,
        command_num = this.commands_sent,
        start = Date.now();

    this.clients[cur_client][this.args.command](this.args.args, function (err, res) {
        if (err) {
            throw err;
        }
        self.commands_completed++;
        self.command_latency.update(Date.now() - start);
        self.fill_pipeline();
    });
};

Test.prototype.print_stats = function () {
    var duration = Date.now() - this.test_start;

    console.log("min/max/avg/p95: " + this.command_latency.print_line() + " " + lpad(duration, 6) + "ms total, " +
        lpad((num_requests / (duration / 1000)).toFixed(2), 8) + " ops/sec");
};

small_str = "1234";
small_buf = new Buffer(small_str);
large_str = (new Array(4097).join("-"));
large_buf = new Buffer(large_str);

tests.push(new Test({descr: "PING", command: "ping", args: [], pipeline: 1}));
tests.push(new Test({descr: "PING", command: "ping", args: [], pipeline: 50}));
tests.push(new Test({descr: "PING", command: "ping", args: [], pipeline: 200}));
tests.push(new Test({descr: "PING", command: "ping", args: [], pipeline: 20000}));

tests.push(new Test({descr: "SET small str", command: "set", args: ["foo_rand000000000000", small_str], pipeline: 1}));
tests.push(new Test({descr: "SET small str", command: "set", args: ["foo_rand000000000000", small_str], pipeline: 50}));
tests.push(new Test({descr: "SET small str", command: "set", args: ["foo_rand000000000000", small_str], pipeline: 200}));
tests.push(new Test({descr: "SET small str", command: "set", args: ["foo_rand000000000000", small_str], pipeline: 20000}));

tests.push(new Test({descr: "SET small buf", command: "set", args: ["foo_rand000000000000", small_buf], pipeline: 1}));
tests.push(new Test({descr: "SET small buf", command: "set", args: ["foo_rand000000000000", small_buf], pipeline: 50}));
tests.push(new Test({descr: "SET small buf", command: "set", args: ["foo_rand000000000000", small_buf], pipeline: 200}));
tests.push(new Test({descr: "SET small buf", command: "set", args: ["foo_rand000000000000", small_buf], pipeline: 20000}));

tests.push(new Test({descr: "GET small str", command: "get", args: ["foo_rand000000000000"], pipeline: 1}));
tests.push(new Test({descr: "GET small str", command: "get", args: ["foo_rand000000000000"], pipeline: 50}));
tests.push(new Test({descr: "GET small str", command: "get", args: ["foo_rand000000000000"], pipeline: 200}));
tests.push(new Test({descr: "GET small str", command: "get", args: ["foo_rand000000000000"], pipeline: 20000}));

tests.push(new Test({descr: "GET small buf", command: "get", args: ["foo_rand000000000000"], pipeline: 1, client_opts: { return_buffers: true} }));
tests.push(new Test({descr: "GET small buf", command: "get", args: ["foo_rand000000000000"], pipeline: 50, client_opts: { return_buffers: true} }));
tests.push(new Test({descr: "GET small buf", command: "get", args: ["foo_rand000000000000"], pipeline: 200, client_opts: { return_buffers: true} }));
tests.push(new Test({descr: "GET small buf", command: "get", args: ["foo_rand000000000000"], pipeline: 20000, client_opts: { return_buffers: true} }));

tests.push(new Test({descr: "SET large str", command: "set", args: ["foo_rand000000000001", large_str], pipeline: 1}));
tests.push(new Test({descr: "SET large str", command: "set", args: ["foo_rand000000000001", large_str], pipeline: 50}));
tests.push(new Test({descr: "SET large str", command: "set", args: ["foo_rand000000000001", large_str], pipeline: 200}));
tests.push(new Test({descr: "SET large str", command: "set", args: ["foo_rand000000000001", large_str], pipeline: 20000}));

tests.push(new Test({descr: "SET large buf", command: "set", args: ["foo_rand000000000001", large_buf], pipeline: 1}));
tests.push(new Test({descr: "SET large buf", command: "set", args: ["foo_rand000000000001", large_buf], pipeline: 50}));
tests.push(new Test({descr: "SET large buf", command: "set", args: ["foo_rand000000000001", large_buf], pipeline: 200}));
tests.push(new Test({descr: "SET large buf", command: "set", args: ["foo_rand000000000001", large_buf], pipeline: 20000}));

tests.push(new Test({descr: "GET large str", command: "get", args: ["foo_rand000000000001"], pipeline: 1}));
tests.push(new Test({descr: "GET large str", command: "get", args: ["foo_rand000000000001"], pipeline: 50}));
tests.push(new Test({descr: "GET large str", command: "get", args: ["foo_rand000000000001"], pipeline: 200}));
tests.push(new Test({descr: "GET large str", command: "get", args: ["foo_rand000000000001"], pipeline: 20000}));

tests.push(new Test({descr: "GET large buf", command: "get", args: ["foo_rand000000000001"], pipeline: 1, client_opts: { return_buffers: true} }));
tests.push(new Test({descr: "GET large buf", command: "get", args: ["foo_rand000000000001"], pipeline: 50, client_opts: { return_buffers: true} }));
tests.push(new Test({descr: "GET large buf", command: "get", args: ["foo_rand000000000001"], pipeline: 200, client_opts: { return_buffers: true} }));
tests.push(new Test({descr: "GET large buf", command: "get", args: ["foo_rand000000000001"], pipeline: 20000, client_opts: { return_buffers: true} }));

tests.push(new Test({descr: "INCR", command: "incr", args: ["counter_rand000000000000"], pipeline: 1}));
tests.push(new Test({descr: "INCR", command: "incr", args: ["counter_rand000000000000"], pipeline: 50}));
tests.push(new Test({descr: "INCR", command: "incr", args: ["counter_rand000000000000"], pipeline: 200}));
tests.push(new Test({descr: "INCR", command: "incr", args: ["counter_rand000000000000"], pipeline: 20000}));

tests.push(new Test({descr: "LPUSH", command: "lpush", args: ["mylist", small_str], pipeline: 1}));
tests.push(new Test({descr: "LPUSH", command: "lpush", args: ["mylist", small_str], pipeline: 50}));
tests.push(new Test({descr: "LPUSH", command: "lpush", args: ["mylist", small_str], pipeline: 200}));
tests.push(new Test({descr: "LPUSH", command: "lpush", args: ["mylist", small_str], pipeline: 20000}));

tests.push(new Test({descr: "LRANGE 10", command: "lrange", args: ["mylist", "0", "9"], pipeline: 1}));
tests.push(new Test({descr: "LRANGE 10", command: "lrange", args: ["mylist", "0", "9"], pipeline: 50}));
tests.push(new Test({descr: "LRANGE 10", command: "lrange", args: ["mylist", "0", "9"], pipeline: 200}));
tests.push(new Test({descr: "LRANGE 10", command: "lrange", args: ["mylist", "0", "9"], pipeline: 20000}));

tests.push(new Test({descr: "LRANGE 100", command: "lrange", args: ["mylist", "0", "99"], pipeline: 1}));
tests.push(new Test({descr: "LRANGE 100", command: "lrange", args: ["mylist", "0", "99"], pipeline: 50}));
tests.push(new Test({descr: "LRANGE 100", command: "lrange", args: ["mylist", "0", "99"], pipeline: 200}));
tests.push(new Test({descr: "LRANGE 100", command: "lrange", args: ["mylist", "0", "99"], pipeline: 20000}));

function next() {
    var test = tests.shift();
    if (test) {
        test.run(function () {
            next();
        });
    } else {
        console.log("End of test.");
        process.exit(0);
    }
}

next();


text:
namespace oless {
	namespace excel {
		namespace structures {
			namespace formulas {

				// see: https://docs.microsoft.com/en-us/openspecs/office_file_formats/ms-xls/55d25224-b32b-499e-9287-9d429f2276a6
				class ExtPtgAreaErr3D : public IParseable {
				public:
					virtual void Parse(unsigned char* buffer, std::size_t max, unsigned int offset) override {
						unsigned int index = offset;

						this->bytesRead = index - offset;
					}
				};
			}
		}
	}
}


text:
package is.hail.expr.ir

import is.hail.utils._

object Children {
  private val none: IndexedSeq[BaseIR] = Array.empty[BaseIR]

  def apply(x: IR): IndexedSeq[BaseIR] = x match {
    case I32(x) => none
    case I64(x) => none
    case F32(x) => none
    case F64(x) => none
    case Str(x) => none
    case UUID4(_) => none
    case True() => none
    case False() => none
    case Literal(_, _) => none
    case EncodedLiteral(_, _) => none
    case Void() => none
    case Cast(v, typ) =>
      Array(v)
    case CastRename(v, typ) =>
      Array(v)
    case NA(typ) => none
    case IsNA(value) =>
      Array(value)
    case Coalesce(values) => values.toFastIndexedSeq
    case Consume(value) => FastIndexedSeq(value)
    case If(cond, cnsq, altr) =>
      Array(cond, cnsq, altr)
    case Let(name, value, body) =>
      Array(value, body)
    case RelationalLet(name, value, body) =>
      Array(value, body)
    case AggLet(name, value, body, _) =>
      Array(value, body)
    case TailLoop(_, args, body) =>
      args.map(_._2).toFastIndexedSeq :+ body
    case Recur(_, args, _) =>
      args.toFastIndexedSeq
    case Ref(name, typ) =>
      none
    case RelationalRef(_, _) =>
      none
    case ApplyBinaryPrimOp(op, l, r) =>
      Array(l, r)
    case ApplyUnaryPrimOp(op, x) =>
      Array(x)
    case ApplyComparisonOp(op, l, r) =>
      Array(l, r)
    case MakeArray(args, typ) =>
      args.toFastIndexedSeq
    case MakeStream(args, _, _) =>
      args.toFastIndexedSeq
    case ArrayRef(a, i, _) =>
      Array(a, i)
    case ArraySlice(a, start, stop, step, _) =>
      if (stop.isEmpty)
        Array(a, start, step)
      else
        Array(a, start, stop.get, step)
    case ArrayLen(a) =>
      Array(a)
    case StreamIota(start, step, _) =>
      Array(start, step)
    case StreamRange(start, stop, step, _, _) =>
      Array(start, stop, step)
    case SeqSample(totalRange, numToSample, rngState, _) =>
      Array(totalRange, numToSample, rngState)
    case StreamDistribute(child, pivots, path, _, _) =>
      Array(child, pivots, path)
    case ArrayZeros(length) =>
      Array(length)
    case MakeNDArray(data, shape, rowMajor, _) =>
      Array(data, shape, rowMajor)
    case NDArrayShape(nd) =>
      Array(nd)
    case NDArrayReshape(nd, shape, _) =>
      Array(nd, shape)
    case NDArrayConcat(nds, _) =>
      Array(nds)
    case ArraySort(a, _, _, lessThan) =>
      Array(a, lessThan)
    case ToSet(a) =>
      Array(a)
    case ToDict(a) =>
      Array(a)
    case ToArray(a) =>
      Array(a)
    case CastToArray(a) =>
      Array(a)
    case ToStream(a, _) =>
      Array(a)
    case LowerBoundOnOrderedCollection(orderedCollection, elem, _) =>
      Array(orderedCollection, elem)
    case GroupByKey(collection) =>
      Array(collection)
    case RNGStateLiteral(_) => none
    case RNGSplit(state, split) =>
      Array(state, split)
    case StreamLen(a) =>
      Array(a)
    case StreamTake(a, len) =>
      Array(a, len)
    case StreamDrop(a, len) =>
      Array(a, len)
    case StreamGrouped(a, size) =>
      Array(a, size)
    case StreamGroupByKey(a, _, _) =>
      Array(a)
    case StreamMap(a, name, body) =>
      Array(a, body)
    case StreamZip(as, names, body, _, _) =>
      as :+ body
    case StreamZipJoin(as, _, _, _, joinF) =>
      as :+ joinF
    case StreamMultiMerge(as, _) =>
      as
    case StreamFilter(a, name, cond) =>
      Array(a, cond)
    case StreamTakeWhile(a, name, cond) =>
      Array(a, cond)
    case StreamDropWhile(a, name, cond) =>
      Array(a, cond)
    case StreamFlatMap(a, name, body) =>
      Array(a, body)
    case StreamFold(a, zero, accumName, valueName, body) =>
      Array(a, zero, body)
    case StreamFold2(a, accum, valueName, seq, result) =>
      Array(a) ++ accum.map(_._2) ++ seq ++ Array(result)
    case StreamScan(a, zero, accumName, valueName, body) =>
      Array(a, zero, body)
    case StreamJoinRightDistinct(left, right, lKey, rKey, l, r, join, joinType) =>
      Array(left, right, join)
    case StreamFor(a, valueName, body) =>
      Array(a, body)
    case StreamAgg(a, name, query) =>
      Array(a, query)
    case StreamAggScan(a, name, query) =>
      Array(a, query)
    case StreamBufferedAggregate(streamChild, initAggs, newKey, seqOps, _, _, _) =>
      Array(streamChild, initAggs, newKey, seqOps)
    case RunAggScan(array, _, init, seq, result, _) =>
      Array(array, init, seq, result)
    case RunAgg(body, result, _) =>
      Array(body, result)
    case NDArrayRef(nd, idxs, _) =>
      nd +: idxs
    case NDArraySlice(nd, slices) =>
      Array(nd, slices)
    case NDArrayFilter(nd, keep) =>
      nd +: keep
    case NDArrayMap(nd, _, body) =>
      Array(nd, body)
    case NDArrayMap2(l, r, _, _, body, _) =>
      Array(l, r, body)
    case NDArrayReindex(nd, _) =>
      Array(nd)
    case NDArrayAgg(nd, _) =>
      Array(nd)
    case NDArrayMatMul(l, r, _) =>
      Array(l, r)
    case NDArrayQR(nd, _, _) =>
      Array(nd)
    case NDArraySVD(nd, _, _, _) =>
      Array(nd)
    case NDArrayInv(nd, errorID) =>
      Array(nd)
    case NDArrayWrite(nd, path) =>
      Array(nd, path)
    case AggFilter(cond, aggIR, _) =>
      Array(cond, aggIR)
    case AggExplode(array, _, aggBody, _) =>
      Array(array, aggBody)
    case AggGroupBy(key, aggIR, _) =>
      Array(key, aggIR)
    case AggArrayPerElement(a, _, _, aggBody, knownLength, _) => Array(a, aggBody) ++ knownLength.toArray[IR]
    case MakeStruct(fields) =>
      fields.map(_._2).toFastIndexedSeq
    case SelectFields(old, fields) =>
      Array(old)
    case InsertFields(old, fields, _) =>
      (old +: fields.map(_._2)).toFastIndexedSeq
    case InitOp(_, args, _) => args
    case SeqOp(_, args, _) => args
    case _: ResultOp => none
    case _: AggStateValue => none
    case _: CombOp => none
    case CombOpValue(_, value, _) => Array(value)
    case InitFromSerializedValue(_, value, _) => Array(value)
    case SerializeAggs(_, _, _, _) => none
    case DeserializeAggs(_, _, _, _) => none
    case Begin(xs) =>
      xs
    case ApplyAggOp(initOpArgs, seqOpArgs, aggSig) =>
      initOpArgs ++ seqOpArgs
    case ApplyScanOp(initOpArgs, seqOpArgs, aggSig) =>
      initOpArgs ++ seqOpArgs
    case AggFold(zero, seqOp, combOp, elementName, accumName, _) =>
      Array(zero, seqOp, combOp)
    case GetField(o, name) =>
      Array(o)
    case MakeTuple(fields) =>
      fields.map(_._2).toFastIndexedSeq
    case GetTupleElement(o, idx) =>
      Array(o)
    case In(i, typ) =>
      none
    case Die(message, typ, errorId) =>
      Array(message)
    case Trap(child) => Array(child)
    case ConsoleLog(message, result) =>
      Array(message, result)
    case ApplyIR(_, _, args, _) =>
      args.toFastIndexedSeq
    case Apply(_, _, args, _, _) =>
      args.toFastIndexedSeq
    case ApplySeeded(_, args, rngState, seed, _) =>
      args.toFastIndexedSeq :+ rngState
    case ApplySpecial(_, _, args, _, _) =>
      args.toFastIndexedSeq
    // from MatrixIR
    case MatrixWrite(child, _) => Array(child)
    case MatrixMultiWrite(children, _) => children
    // from TableIR
    case TableCount(child) => Array(child)
    case MatrixCount(child) => Array(child)
    case TableGetGlobals(child) => Array(child)
    case TableCollect(child) => Array(child)
    case TableAggregate(child, query) => Array(child, query)
    case MatrixAggregate(child, query) => Array(child, query)
    case TableWrite(child, _) => Array(child)
    case TableMultiWrite(children, _) => children
    case TableToValueApply(child, _) => Array(child)
    case MatrixToValueApply(child, _) => Array(child)
    // from BlockMatrixIR
    case BlockMatrixToValueApply(child, _) => Array(child)
    case BlockMatrixCollect(child) => Array(child)
    case BlockMatrixWrite(child, _) => Array(child)
    case BlockMatrixMultiWrite(blockMatrices, _) => blockMatrices
    case CollectDistributedArray(ctxs, globals, _, _, body, dynamicID, _, _) => Array(ctxs, globals, body, dynamicID)
    case ReadPartition(path, _, _) => Array(path)
    case WritePartition(stream, ctx, _) => Array(stream, ctx)
    case WriteMetadata(writeAnnotations, _) => Array(writeAnnotations)
    case ReadValue(path, _, _) => Array(path)
    case WriteValue(value, path, spec) => Array(value, path)
    case LiftMeOut(child) => Array(child)
  }
}


text:
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>Insert title here</title>
</head>
<script type="text/javascript">
	location.href = '/main.do';
</script>
<body>

</body>
</html>


text:
class DashboardController < ApplicationController
  def index
    @motd = MotdFile.new.formatter
    set_my_quotas
  end

  def logout
  end
end


text:
(function (factory) {
    'use strict';
    if (typeof define === 'function' && define.amd) {
        // AMD is used - Register as an anonymous module.
        define(['jquery', 'moment'], factory);
    } else if (typeof exports === 'object') {
        factory(require('jquery'), require('moment'));
    } else {
        // Neither AMD nor CommonJS used. Use global variables.
        if (!jQuery) {
            throw 'twifty-form requires jQuery to be loaded first';
        }
        if (!moment) {
            throw 'twifty-form requires Moment.js to be loaded first';
        }
        factory(jQuery, moment);
    }
}(function ($, moment) {
    'use strict';
    if (!moment) {
        throw new Error('twifty-form requires Moment.js to be loaded first');
    }
    if (!$.fn.datetimepicker) {
        throw new Error('twifty-form requires bootstrap-datetimepicker.js to be loaded first');
    }

    /**
     * Apply existing values to the display fields
     */
    $(document).ready(function(){
        $('[data-provide="datetimepicker"], [data-provide="datetimepicker-inline"]').each(function(){
            var $this = $(this);
            var value = $( $this.data('target') ).val();

            if ( value ) {
                $this.datetimepicker();
                $this.data('DateTimePicker').date( moment(value) );
                $this.on( 'dp.change', eventHandler );
            }
        });
    });

    /**
     * Update ISO 8601 actual value
     */
    var eventHandler = function(e){
        var $this   = $(this);
        var $target = $( $this.data('target') );
        var other   = $this.data('partner');

        $target.val( e.date ? e.date.format() : '' );

        // Check if part of a range
        if ( other ) {
            var $partner = $( other );

            if ( !e.date ) {
                $partner.data('DateTimePicker').date( e.date );
            } else if ( $target.parent().hasClass('left') ) {
                $partner.data('DateTimePicker').minDate( e.date );
            } else {
                $partner.data('DateTimePicker').maxDate( e.date );
            }
        }
    };

    /**
     * Attach on click or focus
     */
    $(document).on(
        'focus.datetimepicker.data-api click.datetimepicker.data-api',
        '[data-provide="datetimepicker"]',
        function () {
            var $this = $(this);

            if ( !$this.data('DateTimePicker') ) {
                $this.datetimepicker();
                $this.on( 'dp.change', eventHandler );
            }
        }
    );

    /**
     * Attach always
     */
    $('[data-provide="datetimepicker-inline"]').each(function(){
        $this = $(this);
        $this.datetimepicker();
        $this.on( 'dp.change', eventHandler );
    });
}));


text:
<?xml version="1.0" encoding="utf-8"?>
<animation-list android:oneshot="false" xmlns:android="http://schemas.android.com/apk/res/android">
    <item android:duration="3500" android:drawable="@drawable/stat_sys_alarm001" />
    <item android:duration="50" android:drawable="@drawable/stat_sys_alarm002" />
    <item android:duration="50" android:drawable="@drawable/stat_sys_alarm003" />
    <item android:duration="50" android:drawable="@drawable/stat_sys_alarm004" />
    <item android:duration="50" android:drawable="@drawable/stat_sys_alarm005" />
    <item android:duration="50" android:drawable="@drawable/stat_sys_alarm006" />
    <item android:duration="50" android:drawable="@drawable/stat_sys_alarm007" />
    <item android:duration="50" android:drawable="@drawable/stat_sys_alarm008" />
    <item android:duration="50" android:drawable="@drawable/stat_sys_alarm009" />
    <item android:duration="50" android:drawable="@drawable/stat_sys_alarm010" />
    <item android:duration="50" android:drawable="@drawable/stat_sys_alarm011" />
    <item android:duration="50" android:drawable="@drawable/stat_sys_alarm012" />
    <item android:duration="50" android:drawable="@drawable/stat_sys_alarm013" />
    <item android:duration="50" android:drawable="@drawable/stat_sys_alarm014" />
    <item android:duration="50" android:drawable="@drawable/stat_sys_alarm015" />
    <item android:duration="50" android:drawable="@drawable/stat_sys_alarm016" />
    <item android:duration="50" android:drawable="@drawable/stat_sys_alarm017" />
    <item android:duration="50" android:drawable="@drawable/stat_sys_alarm018" />
    <item android:duration="50" android:drawable="@drawable/stat_sys_alarm019" />
    <item android:duration="50" android:drawable="@drawable/stat_sys_alarm020" />
	<item android:duration="50" android:drawable="@drawable/stat_sys_alarm021" />
    <item android:duration="50" android:drawable="@drawable/stat_sys_alarm022" />
    <item android:duration="50" android:drawable="@drawable/stat_sys_alarm023" />
    <item android:duration="50" android:drawable="@drawable/stat_sys_alarm024" />
    <item android:duration="50" android:drawable="@drawable/stat_sys_alarm025" />
    <item android:duration="50" android:drawable="@drawable/stat_sys_alarm026" />
    <item android:duration="50" android:drawable="@drawable/stat_sys_alarm027" />
    <item android:duration="50" android:drawable="@drawable/stat_sys_alarm028" />
    <item android:duration="50" android:drawable="@drawable/stat_sys_alarm029" />
    <item android:duration="50" android:drawable="@drawable/stat_sys_alarm030" />
	<item android:duration="50" android:drawable="@drawable/stat_sys_alarm001" />
    <item android:duration="50" android:drawable="@drawable/stat_sys_alarm002" />
    <item android:duration="50" android:drawable="@drawable/stat_sys_alarm003" />
    <item android:duration="50" android:drawable="@drawable/stat_sys_alarm004" />
    <item android:duration="50" android:drawable="@drawable/stat_sys_alarm005" />
    <item android:duration="50" android:drawable="@drawable/stat_sys_alarm006" />
    <item android:duration="50" android:drawable="@drawable/stat_sys_alarm007" />
    <item android:duration="50" android:drawable="@drawable/stat_sys_alarm008" />
    <item android:duration="50" android:drawable="@drawable/stat_sys_alarm009" />
    <item android:duration="50" android:drawable="@drawable/stat_sys_alarm010" />
    <item android:duration="50" android:drawable="@drawable/stat_sys_alarm011" />
    <item android:duration="50" android:drawable="@drawable/stat_sys_alarm012" />
    <item android:duration="50" android:drawable="@drawable/stat_sys_alarm013" />
    <item android:duration="50" android:drawable="@drawable/stat_sys_alarm014" />
    <item android:duration="50" android:drawable="@drawable/stat_sys_alarm015" />
    <item android:duration="50" android:drawable="@drawable/stat_sys_alarm016" />
    <item android:duration="50" android:drawable="@drawable/stat_sys_alarm017" />
    <item android:duration="50" android:drawable="@drawable/stat_sys_alarm018" />
    <item android:duration="50" android:drawable="@drawable/stat_sys_alarm019" />
    <item android:duration="50" android:drawable="@drawable/stat_sys_alarm020" />
	<item android:duration="50" android:drawable="@drawable/stat_sys_alarm021" />
    <item android:duration="50" android:drawable="@drawable/stat_sys_alarm022" />
    <item android:duration="50" android:drawable="@drawable/stat_sys_alarm023" />
    <item android:duration="50" android:drawable="@drawable/stat_sys_alarm024" />
    <item android:duration="50" android:drawable="@drawable/stat_sys_alarm025" />
    <item android:duration="50" android:drawable="@drawable/stat_sys_alarm026" />
    <item android:duration="50" android:drawable="@drawable/stat_sys_alarm027" />
    <item android:duration="50" android:drawable="@drawable/stat_sys_alarm028" />
    <item android:duration="50" android:drawable="@drawable/stat_sys_alarm029" />
    <item android:duration="50" android:drawable="@drawable/stat_sys_alarm030" />
</animation-list>


text:
import sys
import os
import os.path

import argparse

parser = argparse.ArgumentParser()
parser.add_argument('--lammps', type=str, nargs='+',
                    help='directories containing LAMMPS simulation files', default=[])
parser.add_argument('--espp', type=str, nargs='+',
                    help='directories containing ESPResSo++ simulation files', default=[])
parser.add_argument('--rate', type=float, default=0.1)
parser.add_argument('--sites', type=int, default=1)
parser.add_argument('-N', type=int, default=10000)
parser.add_argument('--fit', action='store_true')
parser.add_argument('--plot-all', action='store_true')
args = parser.parse_args()

import numpy as np
from scipy.optimize import leastsq
from io import StringIO
import matplotlib.pyplot as plt
import h5py

plt.rcParams['figure.figsize']= (10,6)
plt.rcParams['font.size'] = 18
plt.rcParams['lines.linewidth'] = 2

NNEIGH=3.25
fraction = float(args.sites)/float(args.N)

# Open lammps log file to extract thermodynamic observables
def from_log(logfile,i0,i1):
    return np.loadtxt(StringIO(u''.join(logfile[i0+1:i1])), unpack=True)

fitfunc = lambda p, t: 1*(1.-np.exp(-t*p[0]-p[1]))
errfunc = lambda p, t, y: fitfunc(p, t) - y

time_max = 0

p_data = []
phi_data = []
for d in args.lammps:
    logfile = open(os.path.join(os.getcwd(), d, 'log.lammps')).readlines()
    start_indices = [(i,l) for (i,l) in enumerate(logfile) if l.startswith('Time ')]
    stop_indices = [(i,l) for (i,l) in enumerate(logfile) if l.startswith('Loop time')]
    time, e_tot, temp, e_kin, e_vdw, e_bond, e_pot, press, rho, n_bonds, n_bonds_max, bonds = from_log(logfile, start_indices[-1][0], stop_indices[-1][0])
    time -= time[0]
    time_max = max(time_max, time.max())
    n_bonds += fraction
    phi_data.append(n_bonds)
    if args.plot_all: plt.plot(time, n_bonds)
    p, success = leastsq(errfunc, [args.rate*NNEIGH*fraction, 0./args.rate], args=(time, n_bonds))
    p_data.append(p)
    print p

if len(args.lammps)>0:
    plt.plot(time, np.mean(phi_data, axis=0))
    p_data = np.array(p_data)
    print "lmp fit rate", p_data.mean(axis=0)[0]
    if args.fit:
        plt.plot(time, fitfunc(p_data.mean(axis=0), time), 'k--')

p_data = []
phi_data = []
for d in args.espp:
    a = h5py.File(os.path.join(os.getcwd(), d, 'dump.h5'), 'r')
    sc_time = a['/observables/statecount/time'][:]
    time_max = max(time_max, sc_time.max())
    sc = a['/observables/statecount/value']
    phi = 1. - sc[:,0]/float(args.N)
    phi_data.append(phi)
    p, success = leastsq(errfunc, [args.rate*NNEIGH*fraction, 0./args.rate], args=(sc_time[:], phi))
    if args.plot_all: plt.plot(sc_time, phi)
    a.close()
    p_data.append(p)
    print p

if len(args.espp)>0:
    plt.plot(sc_time, np.mean(phi_data, axis=0))
    p_data = np.array(p_data)
    print "esp fit rate", p_data.mean(axis=0)[0]
    if args.fit:
        plt.plot(time, fitfunc(p_data.mean(axis=0), time), 'k--')

print "th. rate", args.rate*NNEIGH*fraction
if time_max>0:
    time = np.linspace(0,1,512)*time_max
    plt.plot(time, 1*(1.-np.exp(-time*args.rate*NNEIGH*fraction)))

plt.show()


text:
这里举例如何用 `onCalendarChange` 和 `disabledDate` 来限制动态的日期区间选择。

## en-US

A example shows how to select a dynamic range by using `onCalendarChange` and `disabledDate`.


text:
from sys import version_info
if version_info >= (2, 6, 0):
    def swig_import_helper():
        from os.path import dirname
        import imp
        fp = None
        try:
            fp, pathname, description = imp.find_module('_SimModel_PyCallBack', [dirname(__file__)])
        except ImportError:
            import _SimModel_PyCallBack
            return _SimModel_PyCallBack
        if fp is not None:
            try:
                _mod = imp.load_module('_SimModel_PyCallBack', fp, pathname, description)
            finally:
                fp.close()
            return _mod
    _SimModel_PyCallBack = swig_import_helper()
    del swig_import_helper
else:
    import _SimModel_PyCallBack
del version_info
try:
    _swig_property = property
except NameError:
    pass  # Python < 2.2 doesn't have 'property'.

def _swig_setattr_nondynamic(self, class_type, name, value, static=1):
    if (name == "thisown"):
        return self.this.own(value)
    if (name == "this"):
        if type(value).__name__ == 'SwigPyObject':
            self.__dict__[name] = value
            return
    method = class_type.__swig_setmethods__.get(name, None)
    if method:
        return method(self, value)
    if (not static):
        if _newclass:
            object.__setattr__(self, name, value)
        else:
            self.__dict__[name] = value
    else:
        raise AttributeError("You cannot add attributes to %s" % self)

def _swig_setattr(self, class_type, name, value):
    return _swig_setattr_nondynamic(self, class_type, name, value, 0)

def _swig_getattr_nondynamic(self, class_type, name, static=1):
    if (name == "thisown"):
        return self.this.own()
    method = class_type.__swig_getmethods__.get(name, None)
    if method:
        return method(self)
    if (not static):
        return object.__getattr__(self, name)
    else:
        raise AttributeError(name)

def _swig_getattr(self, class_type, name):
    return _swig_getattr_nondynamic(self, class_type, name, 0)

def _swig_repr(self):
    try:
        strthis = "proxy of " + self.this.__repr__()
    except:
        strthis = ""
    return "<%s.%s; %s >" % (self.__class__.__module__, self.__class__.__name__, strthis,)

try:
    _object = object
    _newclass = 1
except AttributeError:
    class _object:
        pass
    _newclass = 0

try:
    import weakref
    weakref_proxy = weakref.proxy
except:
    weakref_proxy = lambda x: x

class SwigPyIterator(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, SwigPyIterator, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, SwigPyIterator, name)

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _SimModel_PyCallBack.delete_SwigPyIterator
    __del__ = lambda self: None

    def value(self):
        return _SimModel_PyCallBack.SwigPyIterator_value(self)

    def incr(self, n=1):
        return _SimModel_PyCallBack.SwigPyIterator_incr(self, n)

    def decr(self, n=1):
        return _SimModel_PyCallBack.SwigPyIterator_decr(self, n)

    def distance(self, x):
        return _SimModel_PyCallBack.SwigPyIterator_distance(self, x)

    def equal(self, x):
        return _SimModel_PyCallBack.SwigPyIterator_equal(self, x)

    def copy(self):
        return _SimModel_PyCallBack.SwigPyIterator_copy(self)

    def next(self):
        return _SimModel_PyCallBack.SwigPyIterator_next(self)

    def __next__(self):
        return _SimModel_PyCallBack.SwigPyIterator___next__(self)

    def previous(self):
        return _SimModel_PyCallBack.SwigPyIterator_previous(self)

    def advance(self, n):
        return _SimModel_PyCallBack.SwigPyIterator_advance(self, n)

    def __eq__(self, x):
        return _SimModel_PyCallBack.SwigPyIterator___eq__(self, x)

    def __ne__(self, x):
        return _SimModel_PyCallBack.SwigPyIterator___ne__(self, x)

    def __iadd__(self, n):
        return _SimModel_PyCallBack.SwigPyIterator___iadd__(self, n)

    def __isub__(self, n):
        return _SimModel_PyCallBack.SwigPyIterator___isub__(self, n)

    def __add__(self, n):
        return _SimModel_PyCallBack.SwigPyIterator___add__(self, n)

    def __sub__(self, *args):
        return _SimModel_PyCallBack.SwigPyIterator___sub__(self, *args)
    def __iter__(self):
        return self
SwigPyIterator_swigregister = _SimModel_PyCallBack.SwigPyIterator_swigregister
SwigPyIterator_swigregister(SwigPyIterator)

import SimModel
import base
class SimPyCallBack(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, SimPyCallBack, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, SimPyCallBack, name)
    __repr__ = _swig_repr

    def __init__(self):
        if self.__class__ == SimPyCallBack:
            _self = None
        else:
            _self = self
        this = _SimModel_PyCallBack.new_SimPyCallBack(_self, )
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _SimModel_PyCallBack.delete_SimPyCallBack
    __del__ = lambda self: None

    def loadSimClassObj(self, _dataName, _simClassList):
        return _SimModel_PyCallBack.SimPyCallBack_loadSimClassObj(self, _dataName, _simClassList)

    def loadSimGeomClassObj(self, _geomDataName, _simGeomClassList):
        return _SimModel_PyCallBack.SimPyCallBack_loadSimGeomClassObj(self, _geomDataName, _simGeomClassList)

    def loadSimSysClassObj(self, _sysDataName, _simSysClassList):
        return _SimModel_PyCallBack.SimPyCallBack_loadSimSysClassObj(self, _sysDataName, _simSysClassList)

    def getSimClassObj(self, _id):
        return _SimModel_PyCallBack.SimPyCallBack_getSimClassObj(self, _id)

    def getReferenceId(self, _classId, _propertyName):
        return _SimModel_PyCallBack.SimPyCallBack_getReferenceId(self, _classId, _propertyName)

    def getIO(self, _name):
        return _SimModel_PyCallBack.SimPyCallBack_getIO(self, _name)

    def getRefValueType(self, _classId, _propertyName):
        return _SimModel_PyCallBack.SimPyCallBack_getRefValueType(self, _classId, _propertyName)

    def getRefNumberValue(self, _classId, _propertyName):
        return _SimModel_PyCallBack.SimPyCallBack_getRefNumberValue(self, _classId, _propertyName)

    def getRefStringValue(self, _classId, _propertyName):
        return _SimModel_PyCallBack.SimPyCallBack_getRefStringValue(self, _classId, _propertyName)
    def __disown__(self):
        self.this.disown()
        _SimModel_PyCallBack.disown_SimPyCallBack(self)
        return weakref_proxy(self)
SimPyCallBack_swigregister = _SimModel_PyCallBack.SimPyCallBack_swigregister
SimPyCallBack_swigregister(SimPyCallBack)

class CallBack(SimPyCallBack):
    def __init__(self):
        super(CallBack, self).__init__()
        self._sim = None
        self._simGeom = None
        self._simSys = None
        self._dict = {}
    def loadSimClassObj(self, _dataName, _simClassList):
        if self._sim == None:
            self._sim = SimModel.SimModel_(_dataName)
        for id in range(0, _simClassList.size()):
            _objList = getattr(self._sim, _simClassList[id])()
            for subId in range(0, _objList.sizeInt()):
                self._dict[_objList.at(subId).RefId()] = _objList.at(subId)
    def loadSimGeomClassObj(self, _geomDataName, _simGeomClassList):
        if self._simGeom == None:
            self._simGeom = SimModel.SimModel_(_geomDataName)
        for id in range(0, _simGeomClassList.size()):
            _objList = getattr(self._simGeom, _simGeomClassList[id])()
            for subId in range(0, _objList.sizeInt()):
                self._dict[_objList.at(subId).RefId()] = _objList.at(subId)
    def loadSimSysClassObj(self, _sysDataName, _simSysClassList):
        if self._simSys == None:
            self._simSys = SimModel.SimModel_(_sysDataName)
        for id in range(0, _simSysClassList.size()):
            _objList = getattr(self._simSys, _simSysClassList[id])()
            for subId in range(0, _objList.sizeInt()):
                self._dict[_objList.at(subId).RefId()] = _objList.at(subId)
    def getSimClassObj(self, _id):
        if _id in self._dict:
            return self._dict[_id]
        else:
            return None
    def getReferenceId(self, _classId, _propertyName):
        _classObj = self.getSimClassObj(_classId)
        if _classObj is not None and getattr(_classObj, _propertyName)().present():
            return getattr(_classObj, _propertyName)().getValue()
    def getIO(self, _name):
        print(_name)
    def getRefValueType(self, _classId, _propertyName):
        _classObj = self.getSimClassObj(_classId)
        if _classObj is not None and getattr(_classObj, _propertyName)().present():
            if type(getattr(_classObj, _propertyName)().getValue()) is str:
                return "String"
            else:
                return "Number"
    def getRefNumberValue(self, _classId, _propertyName):
        _classObj = self.getSimClassObj(_classId)
        if _classObj is not None and getattr(_classObj, _propertyName)().present():
            return getattr(_classObj, _propertyName)().getValue()
    def getRefStringValue(self, _classId, _propertyName):
        _classObj = self.getSimClassObj(_classId)
        if _classObj is not None and getattr(_classObj, _propertyName)().present():
            return getattr(_classObj, _propertyName)().getValue()

# This file is compatible with both classic and new-style classes.


text:
var initLocalStorage = function(){
	var clave = "compras_storage";//identifica nuestra lista
	//creamos la instancia de la lista (objeto de LocalStorage)
	var lista = new Lista(clave);
	actualizarLista(lista);

	$("#todo_form").on("submit", function(event){
		agregarAct(event, lista);
		actualizarLista(lista);
		event.target.reset();
	});

	//evitamos la validacion del formulario presionando enter
	//!!PROBLEMA DE ACCESIBILIDAD PARA GENE QUE USA TECLADOS
	$("#todo_form *:input").on("keypress", function(event){
		( event.keyCode === 13 ) ? event.preventDefault() : true;
	});

	//resetemos la variable de localStorage
	$("#remove_act").on("click", function(){
		if(window.confirm("¿quieres ELIMINAR LA LISTA forever and ever?")){
			lista.eliminarLista();
			actualizarLista(lista);
		}
	});

	//evento para avisar a todas las ventanas del navegador que se ha producido un cambio e la lista del localStorage
	window.addEventListener("storage", function(){
		actualizarLista(lista);
	}, false);
};

var actualizarLista = function(lista){
	var actividades = lista.obtenerActividades();
	var ol_lista = $("#todo_list");
	ol_lista.html("");
	//agregamos el boton de eliminar la lista de actividades si hay algo en ella
	if(actividades !== null){
		for(var i in actividades){
			var act =  actividades[i];
			var li = $("

");
			li.text(act);
			ol_lista.append(li);
		}
		$("#remove_act").css("display", "block");
	}else $("#remove_act").css("display", "none");
};

var agregarAct = function(e_submit, lista){
	e_submit.preventDefault();
	var actividad = $("#todo").val();
	lista.agregarActividad(actividad);
};


text:
require "katsudo/models/scopes"

module Katsudo
  module Models
    module Resource
      extend ActiveSupport::Concern

      included do
        has_many Katsudo.config.name.underscore.pluralize, :as => :resource, :class_name => Katsudo.config.activity_class_name, :order => :id do
          include Scopes
        end
      end

    end
  end
end