index int64 0 731k | package stringlengths 2 98 ⌀ | name stringlengths 1 76 | docstring stringlengths 0 281k ⌀ | code stringlengths 4 8.19k | signature stringlengths 2 42.8k ⌀ | embed_func_code listlengths 768 768 |
|---|---|---|---|---|---|---|
728,611 | tables.group | _g_width_warning | Issue a :exc:`PerformanceWarning` on too many children. | def _g_width_warning(self):
"""Issue a :exc:`PerformanceWarning` on too many children."""
warnings.warn("""\
group ``%s`` is exceeding the recommended maximum number of children (%d); \
be ready to see PyTables asking for *lots* of memory and possibly slow I/O."""
% (self._v_pathname, self._v_... | (self) | [
-0.040943022817373276,
0.009466149844229221,
-0.03735153004527092,
0.06321027874946594,
-0.02351572923362255,
0.01780354604125023,
0.009996322914958,
0.0033071667421609163,
-0.057874348014593124,
-0.07395055890083313,
0.02544829621911049,
0.0038309262599796057,
-0.0015263846144080162,
-0.0... |
728,612 | tables.exceptions | HDF5ExtError | A low level HDF5 operation failed.
This exception is raised the low level PyTables components used for
accessing HDF5 files. It usually signals that something is not
going well in the HDF5 library or even at the Input/Output level.
Errors in the HDF5 C library may be accompanied by an extensive
H... | class HDF5ExtError(RuntimeError):
"""A low level HDF5 operation failed.
This exception is raised the low level PyTables components used for
accessing HDF5 files. It usually signals that something is not
going well in the HDF5 library or even at the Input/Output level.
Errors in the HDF5 C library... | (*args, **kargs) | [
-0.02037547156214714,
-0.06733914464712143,
-0.027324659749865532,
0.05298755690455437,
0.002714526606723666,
-0.03023274429142475,
-0.010282154195010662,
0.02479424886405468,
-0.03905141353607178,
-0.0917745977640152,
0.0392024852335453,
0.02277369797229767,
0.023585693910717964,
0.015021... |
728,613 | tables.exceptions | __init__ | null | def __init__(self, *args, **kargs):
super().__init__(*args)
self._h5bt_policy = kargs.get('h5bt', self.DEFAULT_H5_BACKTRACE_POLICY)
if self._h5bt_policy and self._dump_h5_backtrace is not None:
self.h5backtrace = self._dump_h5_backtrace()
"""HDF5 back trace.
Contains the HDF5 back tr... | (self, *args, **kargs) | [
-0.03796413913369179,
-0.0563536174595356,
-0.027450405061244965,
0.023608114570379257,
-0.022633204236626625,
-0.030489830300211906,
-0.00887454766780138,
0.06380881369113922,
-0.031789712607860565,
-0.05528312921524048,
0.007488646544516087,
0.08938585966825485,
0.016487447544932365,
0.0... |
728,614 | tables.exceptions | __str__ | Returns a sting representation of the exception.
The actual result depends on policy set in the initializer
:meth:`HDF5ExtError.__init__`.
.. versionadded:: 2.4
| def __str__(self):
"""Returns a sting representation of the exception.
The actual result depends on policy set in the initializer
:meth:`HDF5ExtError.__init__`.
.. versionadded:: 2.4
"""
verbose = bool(self._h5bt_policy in ('VERBOSE', 'verbose'))
if verbose and self.h5backtrace:
bt =... | (self) | [
-0.025671569630503654,
-0.06335961818695068,
0.017971860244870186,
0.045775387436151505,
0.0268168356269598,
-0.05747471749782562,
-0.0017057850491255522,
0.02112574689090252,
0.005338700022548437,
-0.10501205176115036,
0.04017239436507225,
0.028226394206285477,
0.01580466702580452,
0.0072... |
728,615 | tables.exceptions | format_h5_backtrace | Convert the HDF5 trace back represented as a list of tuples.
(see :attr:`HDF5ExtError.h5backtrace`) into a string.
.. versionadded:: 2.4
| def format_h5_backtrace(self, backtrace=None):
"""Convert the HDF5 trace back represented as a list of tuples.
(see :attr:`HDF5ExtError.h5backtrace`) into a string.
.. versionadded:: 2.4
"""
if backtrace is None:
backtrace = self.h5backtrace
if backtrace is None:
return 'No HDF5 ... | (self, backtrace=None) | [
-0.03449191153049469,
-0.0458192452788353,
0.02134346403181553,
0.041922058910131454,
-0.010271086357533932,
-0.05762006714940071,
0.004684817511588335,
0.04392528533935547,
0.005581716075539589,
-0.08304282277822495,
0.029520267620682716,
0.02729850821197033,
-0.011218066327273846,
-0.005... |
728,616 | tables.atom | Int16Atom | Defines an atom of type ``int16``. | from tables.atom import Int16Atom
| (shape=(), dflt=0) | [
0.02612403593957424,
0.026818644255399704,
0.01909324899315834,
-0.014756184071302414,
0.06332791596651077,
-0.008860486559569836,
-0.017534615471959114,
0.016848478466272354,
-0.0676649808883667,
-0.01673835702240467,
0.019652321934700012,
0.025480253621935844,
0.01758544147014618,
0.0163... |
728,624 | tables.description | Int16Col | Defines a non-nested column of a particular type.
The constructor accepts the same arguments as the equivalent
`Atom` class, plus an additional ``pos`` argument for
position information, which is assigned to the `_v_pos`
attribute and an ``attrs`` argument for storing ad... | from tables.description import Int16Col
| (*args, **kwargs) | [
0.011737173423171043,
-0.0107548413798213,
0.028216639533638954,
0.0009061165619641542,
0.04698256775736809,
-0.002201778581365943,
0.01819007843732834,
0.009069633670151234,
-0.06645984202623367,
-0.029622390866279602,
-0.0074055977165699005,
0.038514189422130585,
0.004649139940738678,
0.... |
728,632 | tables.atom | Int32Atom | Defines an atom of type ``int32``. | from tables.atom import Int32Atom
| (shape=(), dflt=0) | [
0.01770661026239395,
0.014138484373688698,
0.019298026338219643,
-0.007483848370611668,
0.0615459643304348,
-0.010034304112195969,
-0.02661854587495327,
0.005616027396172285,
-0.04268348217010498,
-0.05193045362830162,
-0.001890854793600738,
0.020906195044517517,
-0.002845705021172762,
0.0... |
728,640 | tables.description | Int32Col | Defines a non-nested column of a particular type.
The constructor accepts the same arguments as the equivalent
`Atom` class, plus an additional ``pos`` argument for
position information, which is assigned to the `_v_pos`
attribute and an ``attrs`` argument for storing ad... | from tables.description import Int32Col
| (*args, **kwargs) | [
0.0035709154326468706,
-0.023033782839775085,
0.022219030186533928,
0.008877427317202091,
0.05092214420437813,
-0.0007792148971930146,
0.012679614126682281,
-0.0038764483761042356,
-0.04868157207965851,
-0.061751589179039,
-0.025478046387434006,
0.036256566643714905,
-0.01713530160486698,
... |
728,648 | tables.atom | Int64Atom | Defines an atom of type ``int64``. | from tables.atom import Int64Atom
| (shape=(), dflt=0) | [
0.03513523191213608,
0.03775875270366669,
0.05944429710507393,
0.03696173429489136,
0.06412678211927414,
-0.029539497569203377,
-0.043304670602083206,
-0.014387844130396843,
-0.038854651153087616,
-0.035467322915792465,
0.024657759815454483,
0.04659237340092659,
-0.025853287428617477,
0.04... |
728,656 | tables.description | Int64Col | Defines a non-nested column of a particular type.
The constructor accepts the same arguments as the equivalent
`Atom` class, plus an additional ``pos`` argument for
position information, which is assigned to the `_v_pos`
attribute and an ``attrs`` argument for storing ad... | from tables.description import Int64Col
| (*args, **kwargs) | [
0.01925666444003582,
-0.010181395336985588,
0.06274756044149399,
0.045585837215185165,
0.049842748790979385,
-0.009971901774406433,
-0.0014633137034252286,
-0.018971752375364304,
-0.05272538214921951,
-0.04186522588133812,
-0.00490215327590704,
0.04990978538990021,
-0.027234185487031937,
0... |
728,664 | tables.atom | Int8Atom | Defines an atom of type ``int8``. | from tables.atom import Int8Atom
| (shape=(), dflt=0) | [
0.015756165608763695,
0.006322645116597414,
-0.0012023114832118154,
-0.01094692014157772,
0.02342405542731285,
-0.022129258140921593,
-0.035884372889995575,
0.031209653243422508,
-0.044023096561431885,
-0.05175824835896492,
0.025593260303139687,
0.006722014397382736,
-0.010543347336351871,
... |
728,672 | tables.description | Int8Col | Defines a non-nested column of a particular type.
The constructor accepts the same arguments as the equivalent
`Atom` class, plus an additional ``pos`` argument for
position information, which is assigned to the `_v_pos`
attribute and an ``attrs`` argument for storing ad... | from tables.description import Int8Col
| (*args, **kwargs) | [
0.00265657645650208,
-0.02963651530444622,
0.01544579491019249,
0.0073045389726758,
0.01956244185566902,
-0.0108438516035676,
0.009304292500019073,
0.014525406993925571,
-0.04939977079629898,
-0.05816856399178505,
0.0018073086393997073,
0.014993968419730663,
-0.01137098390609026,
0.0053591... |
728,680 | tables.atom | IntAtom | Defines an atom of a signed integral type (int kind). | class IntAtom(Atom):
"""Defines an atom of a signed integral type (int kind)."""
kind = 'int'
signed = True
_deftype = 'int32'
_defvalue = 0
__init__ = _abstract_atom_init(_deftype, _defvalue)
| (itemsize=4, shape=(), dflt=0) | [
0.02767564356327057,
0.0009970037499442697,
0.0234290212392807,
0.005775589495897293,
0.09240943193435669,
-0.0035615379456430674,
-0.012621908448636532,
-0.022140515968203545,
-0.057202380150556564,
-0.06021494418382645,
0.012385984882712364,
0.042538825422525406,
0.009972305968403816,
0.... |
728,688 | tables.description | IntCol | Defines a non-nested column of a particular type.
The constructor accepts the same arguments as the equivalent
`Atom` class, plus an additional ``pos`` argument for
position information, which is assigned to the `_v_pos`
attribute and an ``attrs`` argument for storing ad... | from tables.description import IntCol
| (*args, **kwargs) | [
0.017929768189787865,
-0.029558071866631508,
0.02965889498591423,
0.0019250975456088781,
0.03938835486769676,
-0.00910771731287241,
0.03088557906448841,
0.0037892807740718126,
-0.062208060175180435,
-0.043421294540166855,
-0.027877680957317352,
0.025289878249168396,
-0.020366333425045013,
... |
728,696 | tables.description | IsDescription | Description of the structure of a table or nested column.
This class is designed to be used as an easy, yet meaningful way to
describe the structure of new Table (see :ref:`TableClassDescr`) datasets
or nested columns through the definition of *derived classes*. In order to
define such a class, you mus... | class IsDescription(metaclass=MetaIsDescription):
"""Description of the structure of a table or nested column.
This class is designed to be used as an easy, yet meaningful way to
describe the structure of new Table (see :ref:`TableClassDescr`) datasets
or nested columns through the definition of *deriv... | () | [
0.05826759710907936,
-0.008492742665112019,
0.028432223945856094,
-0.013163750991225243,
0.04379301145672798,
-0.0398789644241333,
0.02682598866522312,
0.004017897881567478,
-0.015277705155313015,
-0.033158618956804276,
-0.0512518547475338,
0.06092619523406029,
-0.010791321285068989,
0.002... |
728,697 | tables.leaf | Leaf | Abstract base class for all PyTables leaves.
A leaf is a node (see the Node class in :class:`Node`) which hangs from a
group (see the Group class in :class:`Group`) but, unlike a group, it can
not have any further children below it (i.e. it is an end node).
This definition includes all nodes which con... | class Leaf(Node):
"""Abstract base class for all PyTables leaves.
A leaf is a node (see the Node class in :class:`Node`) which hangs from a
group (see the Group class in :class:`Group`) but, unlike a group, it can
not have any further children below it (i.e. it is an end node).
This definition inc... | (parentnode, name, new=False, filters=None, byteorder=None, _log=True, track_times=True) | [
0.03522683307528496,
-0.04484127089381218,
-0.016947651281952858,
0.06230783089995384,
-0.010750156827270985,
-0.009046579711139202,
-0.024946630001068115,
0.04076835513114929,
-0.04672108218073845,
-0.06986622512340546,
-0.008273117244243622,
0.004258941859006882,
0.013912543654441833,
0.... |
728,699 | tables.leaf | __init__ | null | def __init__(self, parentnode, name,
new=False, filters=None,
byteorder=None, _log=True,
track_times=True):
self._v_new = new
"""Is this the first time the node has been created?"""
self.nrowsinbuf = None
"""
The number of rows that fits in internal input buffe... | (self, parentnode, name, new=False, filters=None, byteorder=None, _log=True, track_times=True) | [
0.020756104961037636,
-0.02259751595556736,
-0.014838558621704578,
0.017958231270313263,
-0.0603911466896534,
-0.0142843471840024,
-0.03210849687457085,
0.023723816499114037,
0.021971793845295906,
-0.04723309725522995,
-0.004800184164196253,
-0.0031889493111521006,
-0.005868381820619106,
0... |
728,719 | tables.node | _g_create | Create a new HDF5 node and return its object identifier. | def _g_create(self):
"""Create a new HDF5 node and return its object identifier."""
raise NotImplementedError
| (self) | [
0.00394465820863843,
-0.04089353233575821,
-0.019292650744318962,
0.001597672700881958,
-0.005137529689818621,
0.04895510524511337,
-0.02554553747177124,
0.08261389285326004,
-0.05439838767051697,
-0.07220964133739471,
0.03181564807891846,
0.04206487163901329,
0.03222906216979027,
0.030230... |
728,728 | tables.node | _g_open | Open an existing HDF5 node and return its object identifier. | def _g_open(self):
"""Open an existing HDF5 node and return its object identifier."""
raise NotImplementedError
| (self) | [
0.04264923557639122,
-0.07736837863922119,
-0.022057650610804558,
0.05757646635174751,
0.02294062450528145,
0.022574106231331825,
-0.0018815225921571255,
0.0696382075548172,
-0.0420161597430706,
-0.06910508871078491,
-0.003359043737873435,
-0.023690316826105118,
0.015693586319684982,
0.051... |
728,751 | tables.atom | MetaAtom | Atom metaclass.
This metaclass ensures that data about atom classes gets inserted
into the suitable registries.
| class MetaAtom(type):
"""Atom metaclass.
This metaclass ensures that data about atom classes gets inserted
into the suitable registries.
"""
def __init__(cls, name, bases, dict_):
super().__init__(name, bases, dict_)
kind = dict_.get('kind')
itemsize = dict_.get('itemsize... | (name, bases, dict_) | [
0.08641398698091507,
0.04076063632965088,
-0.026658102869987488,
-0.013356033712625504,
0.06565592437982559,
-0.009920340031385422,
0.004317102022469044,
-0.017592189833521843,
-0.03077733889222145,
-0.029788002371788025,
0.021873315796256065,
0.04637286812067032,
-0.0023406785912811756,
0... |
728,752 | tables.atom | __init__ | null | def __init__(cls, name, bases, dict_):
super().__init__(name, bases, dict_)
kind = dict_.get('kind')
itemsize = dict_.get('itemsize')
type_ = dict_.get('type')
deftype = dict_.get('_deftype')
if kind and deftype:
deftype_from_kind[kind] = deftype
if type_:
all_types.add(type_... | (cls, name, bases, dict_) | [
0.050320956856012344,
0.009039063937962055,
-0.024167804047465324,
0.00398262869566679,
-0.008547498844563961,
0.014756486751139164,
-0.005626745987683535,
0.005913094151765108,
-0.02376691624522209,
-0.022659702226519585,
0.003925359342247248,
0.08689718693494797,
-0.0018338228110224009,
... |
728,753 | tables.description | MetaIsDescription | Helper metaclass to return the class variables as a dictionary. | class MetaIsDescription(type):
"""Helper metaclass to return the class variables as a dictionary."""
def __new__(mcs, classname, bases, classdict):
"""Return a new class with a "columns" attribute filled."""
newdict = {"columns": {}, }
if '__doc__' in classdict:
newdict['__... | (classname, bases, classdict) | [
0.05617726594209671,
-0.00478034233674407,
0.027561146765947342,
-0.05598887801170349,
0.04634341597557068,
-0.023831065744161606,
0.03200709819793701,
0.0221920907497406,
-0.001425860682502389,
-0.03247806802392006,
-0.04702161252498627,
0.0695904791355133,
-0.017802653834223747,
0.004730... |
728,754 | tables.description | __new__ | Return a new class with a "columns" attribute filled. | def __new__(mcs, classname, bases, classdict):
"""Return a new class with a "columns" attribute filled."""
newdict = {"columns": {}, }
if '__doc__' in classdict:
newdict['__doc__'] = classdict['__doc__']
for b in bases:
if "columns" in b.__dict__:
newdict["columns"].update(b.... | (mcs, classname, bases, classdict) | [
0.023421036079525948,
-0.017292166128754616,
0.02827305719256401,
-0.0407496839761734,
-0.022527242079377174,
-0.016526058316230774,
-0.0059099807403981686,
0.04136986657977104,
-0.014401018619537354,
-0.01327009592205286,
-0.02639426663517952,
0.07931048423051834,
-0.0031784388702362776,
... |
728,755 | tables.exceptions | NaturalNameWarning | Issued when a non-pythonic name is given for a node.
This is not an error and may even be very useful in certain
contexts, but one should be aware that such nodes cannot be
accessed using natural naming (instead, ``getattr()`` must be
used explicitly).
| class NaturalNameWarning(Warning):
"""Issued when a non-pythonic name is given for a node.
This is not an error and may even be very useful in certain
contexts, but one should be aware that such nodes cannot be
accessed using natural naming (instead, ``getattr()`` must be
used explicitly).
"""
... | null | [
-0.006547231692820787,
0.01070300955325365,
0.034132566303014755,
-0.00035406684037297964,
0.006242028437554836,
-0.008027257397770882,
0.042343780398368835,
0.0403369665145874,
0.09759806841611862,
-0.053314365446567535,
-0.03705916926264763,
0.024650368839502335,
0.06502078473567963,
-0.... |
728,756 | tables.exceptions | NoSuchNodeError | An operation was requested on a node that does not exist.
This exception is raised when an operation gets a path name or a
``(where, name)`` pair leading to a nonexistent node.
| class NoSuchNodeError(NodeError):
"""An operation was requested on a node that does not exist.
This exception is raised when an operation gets a path name or a
``(where, name)`` pair leading to a nonexistent node.
"""
pass
| null | [
-0.020032724365592003,
-0.03711690753698349,
0.047315385192632675,
0.01930426061153412,
-0.016988789662718773,
-0.0008580032736063004,
-0.014326432719826698,
0.03212173655629158,
0.07069557160139084,
-0.02362300455570221,
0.062404971569776535,
-0.02103869616985321,
0.08450166881084442,
-0.... |
728,757 | tables.node | Node | Abstract base class for all PyTables nodes.
This is the base class for *all* nodes in a PyTables hierarchy. It is an
abstract class, i.e. it may not be directly instantiated; however, every
node in the hierarchy is an instance of this class.
A PyTables node is always hosted in a PyTables *file*, under... | class Node(metaclass=MetaNode):
"""Abstract base class for all PyTables nodes.
This is the base class for *all* nodes in a PyTables hierarchy. It is an
abstract class, i.e. it may not be directly instantiated; however, every
node in the hierarchy is an instance of this class.
A PyTables node is al... | (parentnode, name, _log=True) | [
0.038011111319065094,
-0.042491354048252106,
-0.02896953374147415,
0.04670805111527443,
-0.0025530795101076365,
0.008580374531447887,
-0.026030007749795914,
0.062885582447052,
-0.04228862747550011,
-0.06616973876953125,
-0.013217729516327381,
-0.0037909746170043945,
0.054857634007930756,
0... |
728,759 | tables.node | __init__ | null | def __init__(self, parentnode, name, _log=True):
# Remember to assign these values in the root group constructor
# as it does not use this method implementation!
# if the parent node is a softlink, dereference it
if isinstance(parentnode, class_name_dict['SoftLink']):
parentnode = parentnode.der... | (self, parentnode, name, _log=True) | [
0.03083203360438347,
-0.021997807547450066,
-0.01784396730363369,
0.06419927626848221,
-0.0015637847827747464,
0.0007246064487844706,
-0.042747512459754944,
0.07457412779331207,
-0.0238309595733881,
-0.020340172573924065,
0.015181997790932655,
-0.013495109044015408,
0.03615597262978554,
0.... |
728,760 | tables.node | _f_close | Close this node in the tree.
This releases all resources held by the node, so it should not
be used again. On nodes with data, it may be flushed to disk.
You should not need to close nodes manually because they are
automatically opened/closed when they are loaded/evicted from
... | def _f_close(self):
"""Close this node in the tree.
This releases all resources held by the node, so it should not
be used again. On nodes with data, it may be flushed to disk.
You should not need to close nodes manually because they are
automatically opened/closed when they are loaded/evicted from... | (self) | [
0.03688168153166771,
-0.00921177864074707,
0.04469354450702667,
0.039681509137153625,
-0.03812604770064354,
-0.03563731163740158,
-0.061838168650865555,
0.060109879821538925,
0.029346343129873276,
-0.04652553051710129,
-0.032284434884786606,
-0.05181409418582916,
0.04887600615620613,
0.046... |
728,773 | tables.node | _g_copy | Copy this node and return the new one.
Creates and returns a copy of the node in the given `newparent`,
with the given `newname`. If `recursive` copy is stated, all
descendents are copied as well. Additional keyword argumens may
affect the way that the copy is made. Unknown arguments... | def _g_copy(self, newparent, newname, recursive, _log=True, **kwargs):
"""Copy this node and return the new one.
Creates and returns a copy of the node in the given `newparent`,
with the given `newname`. If `recursive` copy is stated, all
descendents are copied as well. Additional keyword argumens may... | (self, newparent, newname, recursive, _log=True, **kwargs) | [
-0.017401238903403282,
-0.029908932745456696,
0.04893546551465988,
0.039325032383203506,
-0.08840183168649673,
0.017171578481793404,
0.0034228325821459293,
0.0346258170902729,
0.09808292239904404,
-0.0046859681606292725,
-0.014185984618961811,
-0.03393683210015297,
0.030209258198738098,
0.... |
728,784 | tables.node | _g_post_init_hook | Code to be run after node creation and before creation logging. | def _g_post_init_hook(self):
"""Code to be run after node creation and before creation logging."""
pass
| (self) | [
-0.03328690305352211,
0.030705394223332405,
0.008139928802847862,
0.05064844712615013,
-0.0004365951754152775,
0.05835661292076111,
-0.04119504243135452,
0.052866362035274506,
0.030178185552358627,
-0.01690705493092537,
0.03919528052210808,
0.0443219356238842,
0.05406621843576431,
-0.00440... |
728,792 | tables.exceptions | NodeError | Invalid hierarchy manipulation operation requested.
This exception is raised when the user requests an operation on the
hierarchy which can not be run because of the current layout of the
tree. This includes accessing nonexistent nodes, moving or copying
or creating over an existing node, non-recursiv... | class NodeError(AttributeError, LookupError):
"""Invalid hierarchy manipulation operation requested.
This exception is raised when the user requests an operation on the
hierarchy which can not be run because of the current layout of the
tree. This includes accessing nonexistent nodes, moving or copyin... | null | [
-0.02843795157968998,
0.002491871127858758,
0.03884034976363182,
0.03969242051243782,
-0.0397634282708168,
-0.013100629672408104,
-0.023893559351563454,
0.04441433027386665,
0.010207129642367363,
-0.061668816953897476,
0.049491267651319504,
-0.0006540329195559025,
0.0366036556661129,
-0.00... |
728,793 | tables.atom | ObjectAtom | Defines an atom of type object.
This class is meant to fit *any* kind of Python object in a row of a
VLArray dataset by using pickle behind the scenes. Due to the fact that
you can not foresee how long will be the output of the pickle
serialization (i.e. the atom already has a *variable* length), you c... | class ObjectAtom(_BufferedAtom):
"""Defines an atom of type object.
This class is meant to fit *any* kind of Python object in a row of a
VLArray dataset by using pickle behind the scenes. Due to the fact that
you can not foresee how long will be the output of the pickle
serialization (i.e. the atom... | () | [
0.04930626228451729,
-0.018935440108180046,
-0.07595352828502655,
0.024988427758216858,
0.045741528272628784,
-0.042388562113046646,
-0.029170813038945198,
0.018917793408036232,
-0.0580945648252964,
-0.03755322843790054,
-0.013553045690059662,
-0.012026563286781311,
-0.0363532193005085,
0.... |
728,794 | tables.atom | __repr__ | null | def __repr__(self):
return '%s()' % self.__class__.__name__
| (self) | [
0.010866970755159855,
-0.05230940133333206,
0.06949929147958755,
0.031878795474767685,
-0.016503000631928444,
-0.065025694668293,
-0.0004970053560100496,
-0.010937420651316643,
0.044665537774562836,
-0.019479528069496155,
-0.04191797226667404,
0.00020832395239267498,
0.011254447512328625,
... |
728,795 | tables.atom | _tobuffer | null | def _tobuffer(self, object_):
return pickle.dumps(object_, pickle.HIGHEST_PROTOCOL)
| (self, object_) | [
-0.01166120357811451,
-0.037335798144340515,
-0.08610838651657104,
-0.010439394973218441,
0.03982928395271301,
-0.06652621179819107,
-0.056186553090810776,
0.07812923192977905,
-0.02559979073703289,
-0.05575434863567352,
0.012309509329497814,
-0.02807665430009365,
-0.05984366685152054,
0.0... |
728,796 | tables.atom | fromarray | null | def fromarray(self, array):
# We have to check for an empty array because of a possible
# bug in HDF5 which makes it claim that a dataset has one
# record when in fact it is empty.
if array.size == 0:
return None
return pickle.loads(array.tobytes())
| (self, array) | [
-0.00587438652291894,
-0.016349144279956818,
-0.016870925202965736,
0.002641517436131835,
0.0006418995908461511,
-0.016931800171732903,
-0.025915132835507393,
0.04476882889866829,
0.013305420987308025,
-0.052178122103214264,
-0.00891376193612814,
0.03895966336131096,
-0.011948789469897747,
... |
728,797 | tables.atom | toarray | null | def toarray(self, object_):
buffer_ = self._tobuffer(object_)
array = np.ndarray(buffer=buffer_, dtype=self.base.dtype,
shape=len(buffer_))
return array
| (self, object_) | [
-0.01576845720410347,
-0.008525042794644833,
-0.010827556252479553,
-0.029822183772921562,
0.005723136942833662,
-0.047800347208976746,
-0.054093584418296814,
0.044017329812049866,
-0.005360744893550873,
0.0075748697854578495,
0.001204289379529655,
-0.04087071120738983,
-0.000062562285165768... |
728,798 | tables.exceptions | OldIndexWarning | Unsupported index format.
This warning is issued when an index in an unsupported format is
found. The index will be marked as invalid and will behave as if
doesn't exist.
| class OldIndexWarning(Warning):
"""Unsupported index format.
This warning is issued when an index in an unsupported format is
found. The index will be marked as invalid and will behave as if
doesn't exist.
"""
pass
| null | [
-0.023624729365110397,
0.002814922947436571,
-0.024928050115704536,
-0.005188531707972288,
0.00838908925652504,
-0.039132583886384964,
0.018889885395765305,
0.04586365073919296,
0.0228328388184309,
-0.08473227173089981,
-0.009816140867769718,
-0.019962236285209656,
0.031081698834896088,
-0... |
728,799 | tables.exceptions | PerformanceWarning | Warning for operations which may cause a performance drop.
This warning is issued when an operation is made on the database
which may cause it to slow down on future operations (i.e. making
the node tree grow too much).
| class PerformanceWarning(Warning):
"""Warning for operations which may cause a performance drop.
This warning is issued when an operation is made on the database
which may cause it to slow down on future operations (i.e. making
the node tree grow too much).
"""
pass
| null | [
-0.02471916750073433,
-0.021030748263001442,
0.022519651800394058,
0.006467420607805252,
0.026428021490573883,
-0.05052117258310318,
0.021166104823350906,
0.007216101977974176,
-0.02067544311285019,
-0.08615332096815109,
-0.01459293719381094,
0.018357492983341217,
0.018645120784640312,
-0.... |
728,800 | tables.atom | PseudoAtom | Pseudo-atoms can only be used in ``VLArray`` nodes.
They can be recognised because they also have `kind`, `type` and
`shape` attributes, but no `size`, `itemsize` or `dflt` ones.
Instead, they have a `base` atom which defines the elements used
for storage.
| class PseudoAtom:
"""Pseudo-atoms can only be used in ``VLArray`` nodes.
They can be recognised because they also have `kind`, `type` and
`shape` attributes, but no `size`, `itemsize` or `dflt` ones.
Instead, they have a `base` atom which defines the elements used
for storage.
"""
def __re... | () | [
0.02086789719760418,
0.003692358499392867,
0.037634171545505524,
-0.012952487915754318,
0.03824581950902939,
-0.021533511579036713,
-0.050118930637836456,
0.013141377829015255,
0.024699674919247627,
-0.018763117492198944,
0.009152191691100597,
0.025095444172620773,
0.017386915162205696,
0.... |
728,802 | tables.atom | fromarray | Convert an `array` of base atoms into an object. | def fromarray(self, array):
"""Convert an `array` of base atoms into an object."""
raise NotImplementedError
| (self, array) | [
0.0032050786539912224,
0.0027413282077759504,
0.00847753044217825,
-0.03377143293619156,
-0.01823795959353447,
-0.029333297163248062,
-0.03675330430269241,
0.026507452130317688,
-0.0012568936217576265,
-0.04278639331459999,
0.002955866977572441,
0.029298624023795128,
-0.016712350770831108,
... |
728,803 | tables.atom | toarray | Convert an `object_` into an array of base atoms. | def toarray(self, object_):
"""Convert an `object_` into an array of base atoms."""
raise NotImplementedError
| (self, object_) | [
-0.014143838547170162,
0.027603985741734505,
-0.0032795758452266455,
-0.04331176355481148,
0.008964885957539082,
-0.04587560147047043,
-0.047789935022592545,
0.029415763914585114,
0.0023117270320653915,
-0.032047972083091736,
0.010135705582797527,
-0.002976188203319907,
0.008682863786816597,... |
728,804 | tables.atom | ReferenceAtom | Defines an atom of type object to read references.
This atom is read-only.
| class ReferenceAtom(Atom):
"""Defines an atom of type object to read references.
This atom is read-only.
"""
kind = 'reference'
type = 'object'
_deftype = 'NoneType'
_defvalue = None
@property
def itemsize(self):
"""Size in bytes of a single item in the atom."""
ret... | (shape=()) | [
0.062185004353523254,
-0.03673025965690613,
-0.001035277615301311,
-0.002858945168554783,
0.02998003549873829,
-0.005138088017702103,
-0.0007070763385854661,
0.008442491292953491,
0.02920696511864662,
-0.05038154497742653,
0.008664041757583618,
0.01445263996720314,
-0.008013531565666199,
0... |
728,806 | tables.atom | __init__ | null | def __init__(self, shape=()):
Atom.__init__(self, self.type, shape, self._defvalue)
| (self, shape=()) | [
0.054463014006614685,
-0.009776725433766842,
0.03808315843343735,
-0.012865009717643261,
-0.008454393595457077,
-0.01659313216805458,
-0.03231608495116234,
-0.004815847612917423,
0.014989272691309452,
-0.008100349456071854,
0.0219933670014143,
0.06186807155609131,
-0.026634324342012405,
0.... |
728,808 | tables.atom | __repr__ | null | def __repr__(self):
return f'ReferenceAtom(shape={self.shape})'
| (self) | [
0.0465119369328022,
-0.05811454728245735,
0.0464104562997818,
0.02496422454714775,
0.01171255111694336,
-0.019602665677666664,
-0.010900706052780151,
0.017792928963899612,
0.044617630541324615,
-0.010283365845680237,
0.004469374194741249,
0.0003792308270931244,
-0.0031797250267118216,
0.04... |
728,813 | tables.atom | StringAtom | Defines an atom of type string.
The item size is the *maximum* length in characters of strings.
| class StringAtom(Atom):
"""Defines an atom of type string.
The item size is the *maximum* length in characters of strings.
"""
kind = 'string'
type = 'string'
_defvalue = b''
@property
def itemsize(self):
"""Size in bytes of a sigle item in the atom."""
return self.dt... | (itemsize, shape=(), dflt=b'') | [
0.05803615599870682,
0.03245909512042999,
-0.011484844610095024,
-0.03095143288373947,
0.05690097436308861,
-0.03760288655757904,
0.007666909601539373,
-0.005720250774174929,
0.05700739845633507,
-0.08726707845926285,
0.012744186446070671,
0.075418621301651,
-0.026002751663327217,
0.045442... |
728,815 | tables.atom | __init__ | null | def __init__(self, itemsize, shape=(), dflt=_defvalue):
if not hasattr(itemsize, '__int__') or int(itemsize) < 0:
raise ValueError("invalid item size for kind ``%s``: %r; "
"it must be a positive integer"
% ('string', itemsize))
Atom.__init__(self, 'S%d'... | (self, itemsize, shape=(), dflt=b'') | [
0.04163539409637451,
0.007609166670590639,
-0.024767091497778893,
-0.048481013625860214,
0.028997331857681274,
-0.005221977364271879,
-0.011734089814126492,
-0.020993225276470184,
-0.0053316825069487095,
-0.01886932924389839,
-0.0018375655636191368,
0.07688155025243759,
-0.022783618420362473... |
728,821 | tables.description | StringCol | Defines a non-nested column of a particular type.
The constructor accepts the same arguments as the equivalent
`Atom` class, plus an additional ``pos`` argument for
position information, which is assigned to the `_v_pos`
attribute and an ``attrs`` argument for storing ad... | from tables.description import StringCol
| (*args, **kwargs) | [
0.01639668643474579,
-0.013004268519580364,
0.00764981796965003,
-0.014008491300046444,
0.026514867320656776,
-0.026734277606010437,
0.048371490091085434,
0.025941025465726852,
0.004162462893873453,
-0.05431244149804115,
-0.03507186099886894,
0.03356974571943283,
-0.05248964950442314,
0.02... |
728,829 | tables.table | Table | This class represents heterogeneous datasets in an HDF5 file.
Tables are leaves (see the Leaf class in :ref:`LeafClassDescr`) whose data
consists of a unidimensional sequence of *rows*, where each row contains
one or more *fields*. Fields have an associated unique *name* and
*position*, with the first... | class Table(tableextension.Table, Leaf):
"""This class represents heterogeneous datasets in an HDF5 file.
Tables are leaves (see the Leaf class in :ref:`LeafClassDescr`) whose data
consists of a unidimensional sequence of *rows*, where each row contains
one or more *fields*. Fields have an associated ... | (parentnode, name, description=None, title='', filters=None, expectedrows=None, chunkshape=None, byteorder=None, _log=True, track_times=True) | [
0.05884139984846115,
-0.039345256984233856,
-0.02329571358859539,
0.05319395661354065,
-0.0028496761806309223,
-0.03762195259332657,
-0.010682392865419388,
0.035670261830091476,
-0.04488888755440712,
-0.08159728348255157,
-0.02466605044901371,
0.007978054694831371,
0.01986987330019474,
0.0... |
728,831 | tables.table | __getitem__ | Get a row or a range of rows from the table.
If key argument is an integer, the corresponding table row is returned
as a record of the current flavor. If key is a slice, the range of rows
determined by it is returned as a structured array of the current
flavor.
In addition, Num... | def __getitem__(self, key):
"""Get a row or a range of rows from the table.
If key argument is an integer, the corresponding table row is returned
as a record of the current flavor. If key is a slice, the range of rows
determined by it is returned as a structured array of the current
flavor.
In ... | (self, key) | [
0.046885229647159576,
-0.04616280645132065,
-0.06360931694507599,
0.02756042405962944,
0.01279591117054224,
0.00824013352394104,
-0.016805356368422508,
0.03187689930200577,
0.014728391543030739,
-0.09145870804786682,
-0.030341751873493195,
0.04637953266501427,
-0.027361758053302765,
0.0152... |
728,832 | tables.table | __init__ | null | def __init__(self, parentnode, name,
description=None, title="", filters=None,
expectedrows=None, chunkshape=None,
byteorder=None, _log=True, track_times=True):
self._v_new = new = description is not None
"""Is this the first time the node has been created?"""
self._v_... | (self, parentnode, name, description=None, title='', filters=None, expectedrows=None, chunkshape=None, byteorder=None, _log=True, track_times=True) | [
0.06556893140077591,
-0.022817177698016167,
-0.02848087251186371,
0.02115257829427719,
-0.004278220701962709,
-0.02742527239024639,
-0.02480657584965229,
0.03822486102581024,
-0.04218335822224617,
-0.07705872505903244,
-0.01782338134944439,
0.03940226137638092,
-0.021964577957987785,
0.035... |
728,833 | tables.table | __iter__ | Iterate over the table using a Row instance.
This is equivalent to calling :meth:`Table.iterrows` with default
arguments, i.e. it iterates over *all the rows* in the table.
See Also
--------
tableextension.Row : the table row iterator and field accessor
Examples
... | def __iter__(self):
"""Iterate over the table using a Row instance.
This is equivalent to calling :meth:`Table.iterrows` with default
arguments, i.e. it iterates over *all the rows* in the table.
See Also
--------
tableextension.Row : the table row iterator and field accessor
Examples
--... | (self) | [
0.07062748074531555,
-0.05141795799136162,
-0.03296671062707901,
-0.023524438962340355,
-0.019552545621991158,
-0.02301892451941967,
-0.01336000394076109,
0.03446519747376442,
0.03715525195002556,
-0.04083828255534172,
0.010886597447097301,
0.03878011927008629,
0.008941272273659706,
0.0374... |
728,835 | tables.table | __repr__ | This provides column metainfo in addition to standard __str__ | """Here is defined the Table class."""
import functools
import math
import operator
import sys
import warnings
from pathlib import Path
import weakref
from time import perf_counter as clock
import numexpr as ne
import numpy as np
from . import tableextension
from .lrucacheextension import ObjectCache, NumCache
from... | (self) | [
0.015860682353377342,
-0.043447304517030716,
-0.003521498991176486,
0.032446105033159256,
0.023804960772395134,
0.0037979227490723133,
-0.05125221237540245,
-0.02192806638777256,
-0.07593058049678802,
-0.09336153417825699,
0.007804905064404011,
0.03350534290075302,
-0.002852506935596466,
0... |
728,836 | tables.table | __setitem__ | Set a row or a range of rows in the table.
It takes different actions depending on the type of the *key*
parameter: if it is an integer, the corresponding table row is
set to *value* (a record or sequence capable of being converted
to the table structure). If *key* is a slice, the row ... | def __setitem__(self, key, value):
"""Set a row or a range of rows in the table.
It takes different actions depending on the type of the *key*
parameter: if it is an integer, the corresponding table row is
set to *value* (a record or sequence capable of being converted
to the table structure). If *... | (self, key, value) | [
0.04509628564119339,
-0.03726080432534218,
-0.05678373947739601,
0.05156008526682854,
-0.032525695860385895,
-0.030007820576429367,
-0.05787356570363045,
0.06584057956933975,
-0.024746587499976158,
-0.06493864953517914,
-0.03596428781747818,
0.0011737952008843422,
0.018404921516776085,
0.0... |
728,838 | tables.table | _add_rows_to_index | Add more elements to the existing index. | def _add_rows_to_index(self, colname, start, nrows, lastrow, update):
"""Add more elements to the existing index."""
# This method really belongs to Column, but since it makes extensive
# use of the table, it gets dangerous when closing the file, since the
# column may be accessing a table which is bein... | (self, colname, start, nrows, lastrow, update) | [
0.00396930705755949,
-0.026361500844359398,
-0.0423758365213871,
0.04435020685195923,
0.01158114429563284,
0.021827761083841324,
-0.0067229135893285275,
0.032631952315568924,
-0.058938611298799515,
-0.06380140781402588,
0.03806147351861,
-0.018610268831253052,
0.01875651814043522,
0.020511... |
728,839 | tables.table | _cache_description_data | Cache some data which is already in the description.
Some information is extracted from `self.description` to build
some useful (but redundant) structures:
* `self.colnames`
* `self.colpathnames`
* `self.coldescrs`
* `self.coltypes`
* `self.coldtypes`
* ... | def _cache_description_data(self):
"""Cache some data which is already in the description.
Some information is extracted from `self.description` to build
some useful (but redundant) structures:
* `self.colnames`
* `self.colpathnames`
* `self.coldescrs`
* `self.coltypes`
* `self.coldtypes... | (self) | [
0.05976845324039459,
-0.04230508953332901,
-0.02246878482401371,
0.021986782550811768,
0.04942391440272331,
-0.055875346064567566,
0.027529824525117874,
0.015034805983304977,
-0.017722902819514275,
-0.046383582055568695,
-0.021096929907798767,
0.07319039851427078,
-0.051908086985349655,
0.... |
728,841 | tables.table | _calc_nrowsinbuf | Calculate the number of rows that fits on a PyTables buffer. | def _calc_nrowsinbuf(self):
"""Calculate the number of rows that fits on a PyTables buffer."""
params = self._v_file.params
# Compute the nrowsinbuf
rowsize = self.rowsize
buffersize = params['IO_BUFFER_SIZE']
if rowsize != 0:
nrowsinbuf = buffersize // rowsize
# The number of ro... | (self) | [
-0.023812301456928253,
-0.0531863309442997,
-0.025764431804418564,
0.038747936487197876,
-0.0009944812627509236,
0.05779041349887848,
0.003936488647013903,
0.010239474475383759,
-0.06799305230379105,
-0.05230234935879707,
0.01690618135035038,
-0.02939244732260704,
-0.07852718979120255,
0.0... |
728,842 | tables.table | _get_column_instance | Get the instance of the column with the given `colpathname`.
If the column does not exist in the table, a `KeyError` is
raised.
| def _get_column_instance(self, colpathname):
"""Get the instance of the column with the given `colpathname`.
If the column does not exist in the table, a `KeyError` is
raised.
"""
try:
return functools.reduce(
getattr, colpathname.split('/'), self.description)
except Attribut... | (self, colpathname) | [
0.11670506000518799,
-0.027660155668854713,
0.03197930008172989,
0.045483238995075226,
0.034588418900966644,
-0.039912424981594086,
0.10196707397699356,
0.05958656966686249,
-0.05130086466670036,
-0.015866246074438095,
-0.015381444245576859,
0.06498109549283981,
-0.019973840564489365,
-0.0... |
728,843 | tables.table | _check_sortby_csi | null | def _check_sortby_csi(self, sortby, checkCSI):
if isinstance(sortby, Column):
icol = sortby
elif isinstance(sortby, str):
icol = self.cols._f_col(sortby)
else:
raise TypeError(
"`sortby` can only be a `Column` or string object, "
"but you passed an object of t... | (self, sortby, checkCSI) | [
0.01935649663209915,
-0.0354594923555851,
0.0037607168778777122,
0.06123160198330879,
0.04339218512177467,
-0.001996881328523159,
0.051142096519470215,
0.058818891644477844,
-0.006685211323201656,
-0.0849565640091896,
0.013772540725767612,
-0.017684051766991615,
0.0009338961681351066,
-0.1... |
728,844 | tables.table | _compile_condition | Compile the `condition` and extract usable index conditions.
This method returns an instance of ``CompiledCondition``. See
the ``compile_condition()`` function in the ``conditions``
module for more information about the compilation process.
This method makes use of the condition cache... | def _compile_condition(self, condition, condvars):
"""Compile the `condition` and extract usable index conditions.
This method returns an instance of ``CompiledCondition``. See
the ``compile_condition()`` function in the ``conditions``
module for more information about the compilation process.
This... | (self, condition, condvars) | [
0.0033962219022214413,
-0.02724411152303219,
-0.0480581670999527,
0.026500752195715904,
0.02376890741288662,
-0.0053661237470805645,
-0.0328378900885582,
-0.003949095495045185,
-0.0025971108116209507,
-0.07303503155708313,
0.017580442130565643,
0.03237329050898552,
0.006699523888528347,
-0... |
728,845 | tables.table | _conv_to_recarr | Try to convert the object into a recarray. | def _conv_to_recarr(self, obj):
"""Try to convert the object into a recarray."""
try:
iflavor = flavor_of(obj)
if iflavor != 'python':
obj = array_as_internal(obj, iflavor)
if hasattr(obj, "shape") and obj.shape == ():
# To allow conversion of scalars (void type) ... | (self, obj) | [
-0.009591727517545223,
0.04829302802681923,
-0.024850493296980858,
0.002490329323336482,
-0.025378478690981865,
-0.06430856883525848,
-0.0037288940511643887,
0.07645222544670105,
0.043294768780469894,
-0.039458077400922775,
-0.009697324596345425,
0.035128600895404816,
0.005090655293315649,
... |
728,846 | tables.table | _disable_indexing_in_queries | Force queries not to use indexing.
*Use only for testing.*
| def _disable_indexing_in_queries(self):
"""Force queries not to use indexing.
*Use only for testing.*
"""
if not self._enabled_indexing_in_queries:
return # already disabled
# The nail avoids setting/getting compiled conditions in/from
# the cache where indexing is used.
self._condi... | (self) | [
0.010321642272174358,
-0.00033571120002307,
0.005504589527845383,
0.037642624229192734,
-0.01873536966741085,
0.00889500416815281,
-0.06538472324609756,
-0.04829944297671318,
-0.007915263995528221,
-0.0645596832036972,
-0.019818240776658058,
-0.007214836310595274,
-0.008912192657589912,
-0... |
728,847 | tables.table | _do_reindex | Common code for `reindex()` and `reindex_dirty()`. | def _do_reindex(self, dirty):
"""Common code for `reindex()` and `reindex_dirty()`."""
indexedrows = 0
for (colname, colindexed) in self.colindexed.items():
if colindexed:
indexcol = self.cols._g_col(colname)
indexedrows = indexcol._do_reindex(dirty)
# Update counters in ... | (self, dirty) | [
-0.0038930189330130816,
-0.014559107832610607,
-0.02027777023613453,
0.07956400513648987,
0.02285623364150524,
0.015700997784733772,
-0.014844580553472042,
0.02294832095503807,
0.014420975930988789,
-0.0895095020532608,
0.015820713713765144,
0.0055483002215623856,
0.02970757894217968,
-0.0... |
728,848 | tables.table | _enable_indexing_in_queries | Allow queries to use indexing.
*Use only for testing.*
| def _enable_indexing_in_queries(self):
"""Allow queries to use indexing.
*Use only for testing.*
"""
if self._enabled_indexing_in_queries:
return # already enabled
self._condition_cache.unnail()
self._enabled_indexing_in_queries = True
| (self) | [
-0.000634668511338532,
-0.022774694487452507,
-0.008117049001157284,
0.04507980868220329,
0.0029998701065778732,
0.028409671038389206,
-0.04732709005475044,
-0.05111728236079216,
-0.009240689687430859,
-0.05245894566178322,
-0.011018390767276287,
-0.033927250653505325,
0.005148624069988728,
... |
728,849 | tables.table | _f_close | null | def _f_close(self, flush=True):
if not self._v_isopen:
return # the node is already closed
# .. note::
#
# As long as ``Table`` objects access their indices on closing,
# ``File.close()`` will need to make *two separate passes*
# to first close ``Table`` objects and then ``Index``... | (self, flush=True) | [
0.019607994705438614,
-0.023910021409392357,
0.02184789441525936,
0.09101807326078415,
-0.08774711191654205,
-0.042593616992235184,
-0.06161497160792351,
0.07871641218662262,
-0.030700823292136192,
-0.06652141362428665,
-0.010737288743257523,
-0.07700982689857483,
0.02234564907848835,
0.02... |
728,864 | tables.table | _g_copy_rows | Copy rows from self to object | def _g_copy_rows(self, object, start, stop, step, sortby, checkCSI):
"""Copy rows from self to object"""
if sortby is None:
self._g_copy_rows_optim(object, start, stop, step)
return
lenbuf = self.nrowsinbuf
absstep = step
if step < 0:
absstep = -step
start, stop = sto... | (self, object, start, stop, step, sortby, checkCSI) | [
-0.011911335401237011,
0.0031370404176414013,
-0.0739794373512268,
0.008785506710410118,
-0.042837753891944885,
-0.016961095854640007,
-0.01819887012243271,
0.04961860552430153,
-0.05428268387913704,
-0.0695665031671524,
-0.009050103835761547,
-0.014386883936822414,
-0.015265882946550846,
... |
728,865 | tables.table | _g_copy_rows_optim | Copy rows from self to object (optimized version) | def _g_copy_rows_optim(self, object, start, stop, step):
"""Copy rows from self to object (optimized version)"""
nrowsinbuf = self.nrowsinbuf
object._open_append(self._v_iobuf)
nrowsdest = object.nrows
for start2 in range(start, stop, step * nrowsinbuf):
# Save the records on disk
st... | (self, object, start, stop, step) | [
-0.017759667709469795,
0.009906813502311707,
-0.05715673789381981,
0.005524442996829748,
-0.036475490778684616,
-0.021123912185430527,
-0.025656787678599358,
0.019512616097927094,
-0.07465080916881561,
-0.06480596959590912,
0.0032425117678940296,
0.0072464048862457275,
0.00710917916148901,
... |
728,866 | tables.table | _g_copy_with_stats | Private part of Leaf.copy() for each kind of leaf. | def _g_copy_with_stats(self, group, name, start, stop, step,
title, filters, chunkshape, _log, **kwargs):
"""Private part of Leaf.copy() for each kind of leaf."""
# Get the private args for the Table flavor of copy()
sortby = kwargs.pop('sortby', None)
propindexes = kwargs.pop('pr... | (self, group, name, start, stop, step, title, filters, chunkshape, _log, **kwargs) | [
-0.021549133583903313,
-0.006293388083577156,
-0.008096625097095966,
-0.005943506024777889,
-0.03242238610982895,
-0.003689459292218089,
-0.004351094830781221,
0.007432746700942516,
-0.06014379486441612,
-0.022051528096199036,
0.01849888265132904,
-0.006620841566473246,
-0.004633691627532244... |
728,867 | tables.table | _g_create | Create a new table on disk. | def _g_create(self):
"""Create a new table on disk."""
# Warning against assigning too much columns...
# F. Alted 2005-06-05
maxColumns = self._v_file.params['MAX_COLUMNS']
if (len(self.description._v_names) > maxColumns):
warnings.warn(
"table ``%s`` is exceeding the recommended... | (self) | [
0.04155790060758591,
-0.0127171715721488,
-0.04428301006555557,
0.009665618650615215,
-0.0060132164508104324,
-0.015650447458028793,
-0.025623587891459465,
0.03883279114961624,
-0.12845857441425323,
-0.07766558229923248,
0.014713692478835583,
0.06275318562984467,
-0.022936327382922173,
0.0... |
728,875 | tables.table | _g_move | Move this node in the hierarchy.
This overloads the Node._g_move() method.
| def _g_move(self, newparent, newname):
"""Move this node in the hierarchy.
This overloads the Node._g_move() method.
"""
itgpathname = _index_pathname_of(self)
# First, move the table to the new location.
super()._g_move(newparent, newname)
# Then move the associated index group (if any).
... | (self, newparent, newname) | [
-0.027281468734145164,
0.008179129101336002,
-0.0508805587887764,
0.009259057231247425,
-0.06493733078241348,
-0.03997505083680153,
-0.007966684177517891,
0.1026817113161087,
-0.00022793568496126682,
-0.03707163780927658,
-0.032627999782562256,
-0.061644431203603745,
0.04167461022734642,
0... |
728,876 | tables.table | _g_open | Opens a table from disk and read the metadata on it.
Creates an user description on the flight to easy the access to
the actual data.
| def _g_open(self):
"""Opens a table from disk and read the metadata on it.
Creates an user description on the flight to easy the access to
the actual data.
"""
# 1. Open the HDF5 table and get some data from it.
self._v_objectid, description, chunksize = self._get_info()
self._v_expectedrows... | (self) | [
0.08458675444126129,
-0.0551239512860775,
-0.06005878746509552,
0.04960424453020096,
0.028421003371477127,
-0.025112835690379143,
0.0038359216414391994,
0.02790924161672592,
-0.08005401492118835,
-0.06802763789892197,
-0.03079703450202942,
0.03485456854104996,
-0.04540049657225609,
0.04591... |
728,877 | tables.table | _g_post_init_hook | null | def _g_post_init_hook(self):
# We are putting here the index-related issues
# as well as filling general info for table
# This is needed because we need first the index objects created
# First, get back the flavor of input data (if any) for
# `Leaf._g_post_init_hook()`.
self._flavor, self._descf... | (self) | [
0.035514555871486664,
-0.03801558166742325,
-0.016079505905508995,
0.06394287198781967,
0.015662668272852898,
-0.010561619885265827,
0.03420151770114899,
0.03138786554336548,
-0.0614001639187336,
-0.06673568487167358,
-0.008487853221595287,
0.021863127127289772,
-0.014776889234781265,
-0.0... |
728,878 | tables.table | _g_pre_kill_hook | Code to be called before killing the node. | def _g_pre_kill_hook(self):
"""Code to be called before killing the node."""
# Flush the buffers before to clean-up them
# self.flush()
# It seems that flushing during the __del__ phase is a sure receipt for
# bringing all kind of problems:
# 1. Illegal Instruction
# 2. Malloc(): trying to c... | (self) | [
0.026133231818675995,
0.0013286530738696456,
-0.022944463416934013,
0.023310989141464233,
-0.028204098343849182,
-0.006762385834008455,
-0.055418577045202255,
0.07953592389822006,
-0.04533914104104042,
-0.10160072892904282,
-0.0336286686360836,
-0.013112431392073631,
0.011912061832845211,
... |
728,879 | tables.table | _g_prop_indexes | Generate index in `other` table for every indexed column here. | def _g_prop_indexes(self, other):
"""Generate index in `other` table for every indexed column here."""
oldcols, newcols = self.colinstances, other.colinstances
for colname in newcols:
if (isinstance(oldcols[colname], Column)):
oldcolindexed = oldcols[colname].is_indexed
if ol... | (self, other) | [
0.010237137787044048,
-0.029468145221471786,
-0.00715541560202837,
0.04391123726963997,
0.01005197037011385,
-0.027422480285167694,
0.0072479997761547565,
0.007856408134102821,
0.009646364487707615,
-0.03724519535899162,
0.011938919313251972,
0.007653605658560991,
0.037703707814216614,
-0.... |
728,880 | tables.table | _g_remove | null | def _g_remove(self, recursive=False, force=False):
# Remove the associated index group (if any).
itgpathname = _index_pathname_of(self)
try:
itgroup = self._v_file._get_node(itgpathname)
except NoSuchNodeError:
pass
else:
itgroup._f_remove(recursive=True)
self.indexed... | (self, recursive=False, force=False) | [
0.05971195176243782,
0.005118421744555235,
-0.014367186464369297,
0.04080494865775108,
-0.014865676872432232,
-0.005639165174216032,
-0.07285071909427643,
0.04970654845237732,
-0.005554600153118372,
-0.03348783031105995,
0.03322078287601471,
-0.005340961739420891,
0.03282910957932472,
-0.0... |
728,884 | tables.table | _g_update_dependent | null | def _g_update_dependent(self):
super()._g_update_dependent()
# Update the new path in columns
self.cols._g_update_table_location(self)
# Update the new path in the Row instance, if cached. Fixes #224.
if 'row' in self.__dict__:
self.__dict__['row'] = tableextension.Row(self)
| (self) | [
0.014071319252252579,
-0.010239976458251476,
-0.023645350709557533,
0.06479552388191223,
-0.021275626495480537,
-0.033452894538640976,
0.012384836561977863,
0.08987654745578766,
-0.00007695928070461378,
-0.035251811146736145,
0.024060485884547234,
-0.026239939033985138,
0.025340482592582703,... |
728,887 | tables.table | _get_condition_key | Get the condition cache key for `condition` with `condvars`.
Currently, the key is a tuple of `condition`, column variables
names, normal variables names, column paths and variable paths
(all are tuples).
| def _get_condition_key(self, condition, condvars):
"""Get the condition cache key for `condition` with `condvars`.
Currently, the key is a tuple of `condition`, column variables
names, normal variables names, column paths and variable paths
(all are tuples).
"""
# Variable names for column and n... | (self, condition, condvars) | [
0.020214227959513664,
-0.016720859333872795,
-0.03966427966952324,
0.03473353758454323,
0.02425343357026577,
0.0055857496336102486,
-0.009070020169019699,
-0.01310922671109438,
0.009788707830011845,
-0.07881911098957062,
-0.0022766024339944124,
0.01310922671109438,
-0.010352740995585918,
-... |
728,888 | tables.table | _get_container | Get the appropriate buffer for data depending on table
nestedness. | def _get_container(self, shape):
"""Get the appropriate buffer for data depending on table
nestedness."""
# This is *much* faster than the numpy.rec.array counterpart
return np.empty(shape=shape, dtype=self._v_dtype)
| (self, shape) | [
0.046693626791238785,
-0.04757720232009888,
-0.06354954838752747,
-0.02390754409134388,
-0.010900276713073254,
0.024876080453395844,
0.005713512189686298,
0.0242133978754282,
0.022752098739147186,
-0.024383315816521645,
0.016065802425146103,
-0.009209587238729,
-0.05090760812163353,
-0.040... |
728,889 | tables.table | _get_enum_map | Return mapping from enumerated column names to `Enum` instances. | def _get_enum_map(self):
"""Return mapping from enumerated column names to `Enum` instances."""
enumMap = {}
for colobj in self.description._f_walk('Col'):
if colobj.kind == 'enum':
enumMap[colobj._v_pathname] = colobj.enum
return enumMap
| (self) | [
0.07805313169956207,
-0.07169913500547409,
-0.02696840465068817,
-0.006755639333277941,
-0.002396289026364684,
-0.03084939904510975,
0.0566805824637413,
-0.016173822805285454,
-0.02889987640082836,
-0.036734070628881454,
-0.01068627554923296,
0.016372384503483772,
0.01065017282962799,
0.03... |
728,890 | tables.table | _get_type_col_names | Returns a list containing 'type_' column names. | def _get_type_col_names(self, type_):
"""Returns a list containing 'type_' column names."""
return [colobj._v_pathname
for colobj in self.description._f_walk('Col')
if colobj.type == type_]
| (self, type_) | [
0.034804947674274445,
0.010434282012283802,
0.05423305928707123,
0.0039274850860238075,
0.042493365705013275,
-0.0017938142409548163,
0.062371619045734406,
-0.0008096921956166625,
-0.03114979714155197,
-0.017015350982546806,
-0.016682246699929237,
0.005158622283488512,
0.006437024567276239,
... |
728,891 | tables.table | _getemptyarray | null | def _getemptyarray(self, dtype):
# Acts as a cache for empty arrays
key = dtype
if key in self._empty_array_cache:
return self._empty_array_cache[key]
else:
self._empty_array_cache[
key] = arr = np.empty(shape=0, dtype=key)
return arr
| (self, dtype) | [
-0.014463528990745544,
-0.031227873638272285,
-0.015859825536608696,
-0.0016751172952353954,
0.01831871271133423,
0.02936614491045475,
-0.03695356845855713,
-0.023903900757431984,
0.06256113201379776,
-0.025923702865839005,
-0.0177830271422863,
-0.04053651914000511,
-0.0018233091104775667,
... |
728,892 | tables.table | _mark_columns_as_dirty | Mark column indexes in `colnames` as dirty. | def _mark_columns_as_dirty(self, colnames):
"""Mark column indexes in `colnames` as dirty."""
assert len(colnames) > 0
if self.indexed:
colindexed, cols = self.colindexed, self.cols
# Mark the proper indexes as dirty
for colname in colnames:
if colindexed[colname]:
... | (self, colnames) | [
0.01009182259440422,
-0.0030989430379122496,
-0.01527789793908596,
0.058343350887298584,
-0.02353006601333618,
-0.06352942436933517,
-0.003344230353832245,
0.0434158630669117,
-0.01459459774196148,
-0.03991175815463066,
-0.040122002363204956,
-0.015488144010305405,
0.05042407289147377,
0.0... |
728,896 | tables.table | _read | Read a range of rows and return an in-memory object. | def _read(self, start, stop, step, field=None, out=None):
"""Read a range of rows and return an in-memory object."""
select_field = None
if field:
if field not in self.coldtypes:
if field in self.description._v_names:
# Remember to select this field
select... | (self, start, stop, step, field=None, out=None) | [
0.03330828621983528,
-0.023788852617144585,
-0.04773344099521637,
0.018260182812809944,
-0.00828813761472702,
0.03455418348312378,
0.005577337462455034,
0.012682845816016197,
-0.05516989156603813,
-0.11859385669231415,
0.02744867652654648,
0.03842814639210701,
-0.03745478764176369,
0.03346... |
728,897 | tables.table | _read_coordinates | Private part of `read_coordinates()` with no flavor conversion. | def _read_coordinates(self, coords, field=None):
"""Private part of `read_coordinates()` with no flavor conversion."""
coords = self._point_selection(coords)
ncoords = len(coords)
# Create a read buffer only if needed
if field is None or ncoords > 0:
# Doing a copy is faster when ncoords is ... | (self, coords, field=None) | [
0.02021932229399681,
-0.008027749136090279,
-0.04920092970132828,
0.06648210436105728,
0.011291874572634697,
0.0011626544874161482,
0.00008448260632576421,
0.02640855498611927,
0.018446002155542374,
-0.0416903980076313,
0.035883646458387375,
0.04182948172092438,
-0.06422199308872223,
0.033... |
728,898 | tables.table | _reindex | Re-index columns in `colnames` if automatic indexing is true. | def _reindex(self, colnames):
"""Re-index columns in `colnames` if automatic indexing is true."""
if self.indexed:
colindexed, cols = self.colindexed, self.cols
colstoindex = []
# Mark the proper indexes as dirty
for colname in colnames:
if colindexed[colname]:
... | (self, colnames) | [
0.0009209919371642172,
-0.013125993311405182,
-0.003194601507857442,
0.028886331245303154,
-0.003688541240990162,
-0.03613078221678734,
-0.00001706136026768945,
0.03336837887763977,
-0.0009975982829928398,
-0.06556593626737595,
-0.03344155475497246,
0.0015321280807256699,
0.05429679155349731... |
728,899 | tables.table | _required_expr_vars | Get the variables required by the `expression`.
A new dictionary defining the variables used in the `expression`
is returned. Required variables are first looked up in the
`uservars` mapping, then in the set of top-level columns of the
table. Unknown variables cause a `NameError` to b... | def _required_expr_vars(self, expression, uservars, depth=1):
"""Get the variables required by the `expression`.
A new dictionary defining the variables used in the `expression`
is returned. Required variables are first looked up in the
`uservars` mapping, then in the set of top-level columns of the
... | (self, expression, uservars, depth=1) | [
0.03193657845258713,
-0.032819248735904694,
-0.0013051970163360238,
0.05749386548995972,
0.0088969049975276,
0.03183627501130104,
0.03919854015111923,
-0.03566786274313927,
-0.04497601091861725,
-0.07402385026216507,
0.010085498914122581,
0.02507583051919937,
-0.014042465016245842,
-0.0071... |
728,900 | tables.table | _save_buffered_rows | Update the indexes after a flushing of rows. | def _save_buffered_rows(self, wbufRA, lenrows):
"""Update the indexes after a flushing of rows."""
self._open_append(wbufRA)
self._append_records(lenrows)
self._close_append()
if self.indexed:
self._unsaved_indexedrows += lenrows
# The table caches for indexed queries are dirty now
... | (self, wbufRA, lenrows) | [
-0.022724704816937447,
-0.028261777013540268,
-0.1018681600689888,
0.04373763129115105,
0.017336102202534676,
-0.018847007304430008,
-0.0746893435716629,
-0.007759761996567249,
-0.015248783864080906,
-0.04904763400554657,
-0.014506431296467781,
-0.07594697922468185,
0.01624440774321556,
0.... |
728,901 | tables.table | _set_column_indexing | Mark the referred column as indexed or non-indexed. | def _set_column_indexing(self, colpathname, indexed):
"""Mark the referred column as indexed or non-indexed."""
colindexed = self.colindexed
isindexed, wasindexed = bool(indexed), colindexed[colpathname]
if isindexed == wasindexed:
return # indexing state is unchanged
# Changing the set of ... | (self, colpathname, indexed) | [
0.05597284436225891,
0.02285940758883953,
0.008075046353042126,
0.1084098145365715,
0.014912537299096584,
-0.03017866238951683,
0.0018154489807784557,
0.015319162048399448,
-0.042041510343551636,
-0.06467108428478241,
0.012136878445744514,
0.007659581024199724,
-0.006598819978535175,
0.001... |
728,902 | tables.table | _where | Low-level counterpart of `self.where()`. | def _where(self, condition, condvars, start=None, stop=None, step=None):
"""Low-level counterpart of `self.where()`."""
if profile:
tref = clock()
if profile:
show_stats("Entering table._where", tref)
# Adjust the slice to be used.
(start, stop, step) = self._process_range_read(start... | (self, condition, condvars, start=None, stop=None, step=None) | [
0.043089017271995544,
-0.05193993076682091,
-0.020269684493541718,
0.0017198727000504732,
-0.03072323277592659,
-0.01072672475129366,
0.015771381556987762,
0.040794335305690765,
-0.04640355333685875,
-0.05703921988606453,
0.008923760615289211,
-0.007116243708878756,
0.027153728529810905,
-... |
728,903 | tables.table | append | Append a sequence of rows to the end of the table.
The rows argument may be any object which can be converted to
a structured array compliant with the table structure
(otherwise, a ValueError is raised). This includes NumPy
structured arrays, lists of tuples or array records, and a
... | def append(self, rows):
"""Append a sequence of rows to the end of the table.
The rows argument may be any object which can be converted to
a structured array compliant with the table structure
(otherwise, a ValueError is raised). This includes NumPy
structured arrays, lists of tuples or array reco... | (self, rows) | [
-0.008938531391322613,
0.004040839616209269,
-0.04677636921405792,
0.0034103712532669306,
-0.007229695096611977,
-0.03935680538415909,
-0.05000904202461243,
0.0491521880030632,
-0.06169339641928673,
-0.04739953577518463,
-0.004267224110662937,
-0.020077617838978767,
-0.006290078163146973,
... |
728,904 | tables.table | append_where | Append rows fulfilling the condition to the dstTable table.
dstTable must be capable of taking the rows resulting from the query,
i.e. it must have columns with the expected names and compatible
types. The meaning of the other arguments is the same as in the
:meth:`Table.where` method.
... | def append_where(self, dstTable, condition=None, condvars=None,
start=None, stop=None, step=None):
"""Append rows fulfilling the condition to the dstTable table.
dstTable must be capable of taking the rows resulting from the query,
i.e. it must have columns with the expected names and compa... | (self, dstTable, condition=None, condvars=None, start=None, stop=None, step=None) | [
-0.006113818380981684,
0.001325190532952547,
-0.05410683900117874,
-0.006109276320785284,
-0.004158395808190107,
-0.0041515822522342205,
-0.017778221517801285,
0.04284214973449707,
-0.05025504156947136,
-0.059630170464515686,
0.006876910105347633,
-0.031232254579663277,
-0.003249953268095851... |
728,906 | tables.table | col | Get a column from the table.
If a column called name exists in the table, it is read and returned as
a NumPy object. If it does not exist, a KeyError is raised.
Examples
--------
::
narray = table.col('var2')
That statement is equivalent to::
... | def col(self, name):
"""Get a column from the table.
If a column called name exists in the table, it is read and returned as
a NumPy object. If it does not exist, a KeyError is raised.
Examples
--------
::
narray = table.col('var2')
That statement is equivalent to::
narray = ... | (self, name) | [
0.05779193714261055,
-0.003437923965975642,
0.02064495161175728,
0.045154303312301636,
0.04261285066604614,
0.018625713884830475,
0.01079246960580349,
0.031141499057412148,
0.013412254862487316,
-0.06419778615236282,
-0.02294270321726799,
0.030236322432756424,
0.006545111071318388,
0.00235... |
728,907 | tables.table | copy | Copy this table and return the new one.
This method has the behavior and keywords described in
:meth:`Leaf.copy`. Moreover, it recognises the following additional
keyword arguments.
Parameters
----------
sortby
If specified, and sortby corresponds to a colu... | def copy(self, newparent=None, newname=None, overwrite=False,
createparents=False, **kwargs):
"""Copy this table and return the new one.
This method has the behavior and keywords described in
:meth:`Leaf.copy`. Moreover, it recognises the following additional
keyword arguments.
Parameters
... | (self, newparent=None, newname=None, overwrite=False, createparents=False, **kwargs) | [
-0.023440489545464516,
-0.003948531579226255,
0.032931290566921234,
-0.022724203765392303,
-0.06220952048897743,
-0.014997257851064205,
-0.0028875316493213177,
0.04143719747662544,
0.006777864880859852,
-0.04304884374141693,
-0.011908270418643951,
-0.02786356210708618,
0.0056631434708833694,... |
728,909 | tables.table | flush | Flush the table buffers. | def flush(self):
"""Flush the table buffers."""
if self._v_file._iswritable():
# Flush rows that remains to be appended
if 'row' in self.__dict__:
self.row._flush_buffered_rows()
if self.indexed and self.autoindex:
# Flush any unindexed row
rowsadded =... | (self) | [
-0.013711773790419102,
-0.021038206294178963,
-0.06701970100402832,
0.03291177749633789,
-0.00123463140334934,
-0.03472359478473663,
-0.10702043771743774,
0.039156392216682434,
-0.05653578042984009,
-0.03778433799743652,
-0.045594505965709686,
-0.08443427085876465,
0.004263490904122591,
0.... |
728,910 | tables.table | flush_rows_to_index | Add remaining rows in buffers to non-dirty indexes.
This can be useful when you have chosen non-automatic indexing
for the table (see the :attr:`Table.autoindex` property in
:class:`Table`) and you want to update the indexes on it.
| def flush_rows_to_index(self, _lastrow=True):
"""Add remaining rows in buffers to non-dirty indexes.
This can be useful when you have chosen non-automatic indexing
for the table (see the :attr:`Table.autoindex` property in
:class:`Table`) and you want to update the indexes on it.
"""
rowsadded =... | (self, _lastrow=True) | [
-0.022978929802775383,
-0.01742815226316452,
-0.0735177993774414,
0.05282937362790108,
0.027855487540364265,
-0.007088556420058012,
-0.04414762184023857,
0.029056154191493988,
-0.031143469735980034,
-0.08157150447368622,
-0.013151927851140499,
-0.06919539719820023,
-0.01305033266544342,
0.... |
728,912 | tables.table | get_enum | Get the enumerated type associated with the named column.
If the column named colname (a string) exists and is of an enumerated
type, the corresponding Enum instance (see :ref:`EnumClassDescr`) is
returned. If it is not of an enumerated type, a TypeError is raised. If
the column does no... | def get_enum(self, colname):
"""Get the enumerated type associated with the named column.
If the column named colname (a string) exists and is of an enumerated
type, the corresponding Enum instance (see :ref:`EnumClassDescr`) is
returned. If it is not of an enumerated type, a TypeError is raised. If
... | (self, colname) | [
0.04816538095474243,
-0.042038459330797195,
-0.029766913503408432,
0.020877566188573837,
0.01164291799068451,
-0.01466210838407278,
0.03286578878760338,
-0.002985987812280655,
-0.017468804493546486,
-0.0796145349740982,
-0.03010336123406887,
0.02358686923980713,
-0.01960260048508644,
-0.00... |
728,913 | tables.table | get_where_list | Get the row coordinates fulfilling the given condition.
The coordinates are returned as a list of the current flavor. sort
means that you want to retrieve the coordinates ordered. The default is
to not sort them.
The meaning of the other arguments is the same as in the
:meth:`... | def get_where_list(self, condition, condvars=None, sort=False,
start=None, stop=None, step=None):
"""Get the row coordinates fulfilling the given condition.
The coordinates are returned as a list of the current flavor. sort
means that you want to retrieve the coordinates ordered. The def... | (self, condition, condvars=None, sort=False, start=None, stop=None, step=None) | [
0.05796395242214203,
-0.051292359828948975,
-0.014768971130251884,
-0.01426680851727724,
0.022328317165374756,
0.009792177937924862,
0.0006136924494057894,
0.022561464458703995,
-0.013630136847496033,
-0.029484139755368233,
-0.0038895211182534695,
-0.042504508048295975,
-0.038415465503931046... |
728,915 | tables.table | iterrows | Iterate over the table using a Row instance.
If a range is not supplied, *all the rows* in the table are iterated
upon - you can also use the :meth:`Table.__iter__` special method for
that purpose. If you want to iterate over a given *range of rows* in
the table, you may use the start, ... | def iterrows(self, start=None, stop=None, step=None):
"""Iterate over the table using a Row instance.
If a range is not supplied, *all the rows* in the table are iterated
upon - you can also use the :meth:`Table.__iter__` special method for
that purpose. If you want to iterate over a given *range of row... | (self, start=None, stop=None, step=None) | [
0.039126988500356674,
-0.047145694494247437,
-0.05144143104553223,
-0.028387650847434998,
-0.04227719455957413,
0.025810210034251213,
-0.03117987886071205,
0.033453039824962616,
-0.021711362525820732,
-0.029855361208319664,
0.029747966676950455,
0.017254536971449852,
-0.004622390028089285,
... |
728,916 | tables.table | itersequence | Iterate over a sequence of row coordinates. | def itersequence(self, sequence):
"""Iterate over a sequence of row coordinates."""
if not hasattr(sequence, '__getitem__'):
raise TypeError("Wrong 'sequence' parameter type. Only sequences "
"are suported.")
# start, stop and step are necessary for the new iterator for
#... | (self, sequence) | [
0.019858431071043015,
0.010720114223659039,
-0.009000768885016441,
0.015070055611431599,
-0.011029595509171486,
0.021852871403098106,
-0.04714443162083626,
0.0687393993139267,
0.04566579312086105,
-0.0065764933824539185,
-0.0034236451610922813,
0.02498207800090313,
0.0024049333296716213,
0... |
728,917 | tables.table | itersorted | Iterate table data following the order of the index of sortby
column.
The sortby column must have associated a full index. If you want to
ensure a fully sorted order, the index must be a CSI one. You may want
to use the checkCSI argument in order to explicitly check for the
ex... | def itersorted(self, sortby, checkCSI=False,
start=None, stop=None, step=None):
"""Iterate table data following the order of the index of sortby
column.
The sortby column must have associated a full index. If you want to
ensure a fully sorted order, the index must be a CSI one. You may ... | (self, sortby, checkCSI=False, start=None, stop=None, step=None) | [
0.01753891073167324,
0.0025908732786774635,
-0.039370499551296234,
0.009968351572751999,
0.019469717517495155,
-0.004606994800269604,
0.009914468042552471,
0.07615461200475693,
-0.022576969116926193,
-0.048889823257923126,
0.003545051207765937,
-0.03254532068967819,
-0.009591170586645603,
... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.