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,165 | tables.table | _g_col | Like `self._f_col()` but it does not check arguments. | def _g_col(self, colname):
"""Like `self._f_col()` but it does not check arguments."""
# Get the Column or Description object
inames = colname.split('/')
cols = self
for iname in inames:
cols = cols.__dict__[iname]
return cols
| (self, colname) | [
0.06384081393480301,
-0.03195597231388092,
0.003247612388804555,
0.054949332028627396,
0.015533411875367165,
-0.019436771050095558,
0.07568425685167313,
0.02646103873848915,
0.017685148864984512,
-0.05157057195901871,
-0.007922306656837463,
0.038873542100191116,
-0.01253698393702507,
0.006... |
728,166 | tables.table | _g_update_table_location | Updates the location information about the associated `table`. | def _g_update_table_location(self, table):
"""Updates the location information about the associated `table`."""
myDict = self.__dict__
myDict['_v__tableFile'] = table._v_file
myDict['_v__tablePath'] = table._v_pathname
# Update the locations in individual columns.
for colname in self._v_colnames... | (self, table) | [
0.051970284432172775,
-0.007284692022949457,
-0.0527079738676548,
0.03072480298578739,
-0.014421846717596054,
-0.023163476958870888,
0.009599195793271065,
0.05473662540316582,
-0.04728595167398453,
-0.013508954085409641,
-0.08785892277956009,
-0.037659093737602234,
-0.014006895944476128,
0... |
728,167 | tables.table | Column | Accessor for a non-nested column in a table.
Each instance of this class is associated with one *non-nested* column of a
table. These instances are mainly used to read and write data from the
table columns using item access (like the Cols class - see
:ref:`ColsClassDescr`), but there are a few other as... | class Column:
"""Accessor for a non-nested column in a table.
Each instance of this class is associated with one *non-nested* column of a
table. These instances are mainly used to read and write data from the
table columns using item access (like the Cols class - see
:ref:`ColsClassDescr`), but the... | (table, name, descr) | [
0.07182144373655319,
-0.04089365154504776,
-0.02411569096148014,
0.07842329889535904,
0.03387129679322243,
-0.036457374691963196,
0.009240493178367615,
0.0312221460044384,
0.009124856442213058,
-0.061477139592170715,
-0.02613409236073494,
0.022854190319776535,
0.009156393818557262,
0.04226... |
728,168 | tables.table | __getitem__ | Get a row or a range of rows from a column.
If key argument is an integer, the corresponding element in the column
is returned as an object of the current flavor. If key is a slice, the
range of elements determined by it is returned as an array of the
current flavor.
Examples
... | def __getitem__(self, key):
"""Get a row or a range of rows from a column.
If key argument is an integer, the corresponding element in the column
is returned as an object of the current flavor. If key is a slice, the
range of elements determined by it is returned as an array of the
current flavor.
... | (self, key) | [
0.06174001842737198,
-0.05681786686182022,
-0.05394984409213066,
0.006956894416362047,
0.027343114838004112,
0.01033844891935587,
0.03517204523086548,
0.03451317176222801,
0.02106446959078312,
-0.07402601093053818,
-0.006956894416362047,
0.04476441815495491,
-0.010726019740104675,
0.001068... |
728,169 | tables.table | __init__ | null | def __init__(self, table, name, descr):
self._table_file = table._v_file
self._table_path = table._v_pathname
self.name = name
"""The name of the associated column."""
self.pathname = descr._v_colobjects[name]._v_pathname
"""The complete pathname of the associated column (the same as
Column.... | (self, table, name, descr) | [
0.03077428787946701,
0.013854969292879105,
0.041779786348342896,
0.04846903681755066,
-0.003620229661464691,
-0.03964969143271446,
0.04465728625655174,
0.05000121146440506,
-0.03230646252632141,
-0.0027723952662199736,
-0.05609254166483879,
0.07578659057617188,
-0.03574451431632042,
0.0506... |
728,170 | tables.table | __iter__ | Iterate through all items in the column. | def __iter__(self):
"""Iterate through all items in the column."""
table = self.table
itemsize = self.dtype.itemsize
nrowsinbuf = table._v_file.params['IO_BUFFER_SIZE'] // itemsize
buf = np.empty((nrowsinbuf, ), self._itemtype)
max_row = len(self)
for start_row in range(0, len(self), nrowsin... | (self) | [
0.05730490759015083,
-0.04001402109861374,
-0.09707039594650269,
0.01461914274841547,
0.01169886440038681,
-0.006430824752897024,
-0.0018950740341097116,
0.04349350184202194,
0.01123730093240738,
-0.025261735543608665,
0.004762094467878342,
0.013021421618759632,
-0.015950575470924377,
0.07... |
728,171 | tables.table | __len__ | Get the number of elements in the column.
This matches the length in rows of the parent table.
| def __len__(self):
"""Get the number of elements in the column.
This matches the length in rows of the parent table.
"""
return self.table.nrows
| (self) | [
-0.016571316868066788,
-0.009789138101041317,
0.010813486762344837,
0.054257433861494064,
0.006344352848827839,
0.023097408935427666,
0.021494798362255096,
0.015778273344039917,
0.012556531466543674,
-0.03915655240416527,
-0.018008708953857422,
-0.03149046003818512,
-0.0064187003299593925,
... |
728,172 | tables.table | __repr__ | A detailed string representation for this object. | def __repr__(self):
"""A detailed string representation for this object."""
return str(self)
| (self) | [
0.00652884179726243,
-0.052965886890888214,
0.04554435983300209,
0.0026780504267662764,
0.034026991575956345,
-0.07414523512125015,
-0.021791977807879448,
0.0022284267470240593,
0.060527440160512924,
-0.04323388636112213,
-0.043864015489816666,
-0.0034153894521296024,
-0.00044770920067094266... |
728,173 | tables.table | __setitem__ | Set a row or a range of rows in a column.
If key argument is an integer, the corresponding element is set to
value. If key is a slice, the range of elements determined by it is
set to value.
Examples
--------
::
# Modify row 1
table.cols.col1[... | def __setitem__(self, key, value):
"""Set a row or a range of rows in a column.
If key argument is an integer, the corresponding element is set to
value. If key is a slice, the range of elements determined by it is
set to value.
Examples
--------
::
# Modify row 1
table.cols... | (self, key, value) | [
0.049011822789907455,
-0.01221618801355362,
-0.0498574860394001,
0.05085022374987602,
-0.014238431118428707,
-0.023513173684477806,
-0.03838585317134857,
0.058277372270822525,
-0.0331096388399601,
-0.07033729553222656,
-0.019156157970428467,
0.014863488264381886,
0.029157070443034172,
0.03... |
728,174 | tables.table | __str__ | The string representation for this object. | def __str__(self):
"""The string representation for this object."""
return (f"{self._table_path}.cols.{self.pathname.replace('/', '.')} "
f"({self.__class__.__name__}{self.shape}, "
f"{self.descr._v_types[self.name]}, idx={self.index})")
| (self) | [
0.016711071133613586,
-0.06712767481803894,
0.01824314147233963,
0.002419872907921672,
0.01306244358420372,
-0.05745704099535942,
0.0279137771576643,
0.012238845229148865,
-0.008089859038591385,
-0.057563308626413345,
-0.02314930595457554,
0.019854914397001266,
-0.029135890305042267,
0.017... |
728,175 | tables.table | _do_reindex | Common code for reindex() and reindex_dirty() codes. | def _do_reindex(self, dirty):
"""Common code for reindex() and reindex_dirty() codes."""
index = self.index
dodirty = True
if dirty and not index.dirty:
dodirty = False
if index is not None and dodirty:
self._table_file._check_writable()
# Get the old index parameters
... | (self, dirty) | [
0.008785801008343697,
-0.003725566202774644,
-0.005619415082037449,
0.037922997027635574,
0.01141371764242649,
-0.01791217364370823,
-0.04742215573787689,
0.02906816080212593,
-0.020231734961271286,
-0.10471165180206299,
0.029012933373451233,
0.018565699458122253,
0.03280523419380188,
0.00... |
728,176 | tables.table | _g_update_table_location | Updates the location information about the associated `table`. | def _g_update_table_location(self, table):
"""Updates the location information about the associated `table`."""
self._table_file = table._v_file
self._table_path = table._v_pathname
| (self, table) | [
0.04360707104206085,
0.01074440497905016,
-0.04619482159614563,
0.027381185442209244,
-0.0011507178423926234,
-0.02524803951382637,
0.004747121129184961,
0.08196870237588882,
-0.0583292655646801,
-0.010141179896891117,
-0.06672196835279465,
-0.03297631815075874,
-0.01643570512533188,
0.055... |
728,177 | tables.table | close | Close this column. | def close(self):
"""Close this column."""
self.__dict__.clear()
| (self) | [
0.027360670268535614,
0.0062194406054914,
0.038558099418878555,
0.016650088131427765,
-0.03115805983543396,
-0.06315997987985611,
-0.028723835945129395,
0.08867064118385315,
0.01778605952858925,
-0.037194933742284775,
-0.03318657726049423,
-0.05945996195077896,
0.026419436559081078,
0.0235... |
728,178 | tables.table | create_csindex | Create a completely sorted index (CSI) for this column.
This method guarantees the creation of an index with zero entropy, that
is, a completely sorted index (CSI) -- provided that the number of rows
in the table does not exceed the 2**48 figure (that is more than 100
trillions of rows)... | def create_csindex(self, filters=None, tmp_dir=None,
_blocksizes=None, _testmode=False, _verbose=False):
"""Create a completely sorted index (CSI) for this column.
This method guarantees the creation of an index with zero entropy, that
is, a completely sorted index (CSI) -- provided that ... | (self, filters=None, tmp_dir=None, _blocksizes=None, _testmode=False, _verbose=False) | [
-0.027735721319913864,
-0.019600147381424904,
-0.0036694644950330257,
-0.035889096558094025,
0.04219105467200279,
0.006475525442510843,
-0.04746048524975777,
0.01227456983178854,
-0.011420067399740219,
-0.0827443078160286,
0.019706960767507553,
0.027628909796476364,
-0.03286273404955864,
-... |
728,179 | tables.table | create_index | Create an index for this column.
.. warning::
In some situations it is useful to get a completely sorted
index (CSI). For those cases, it is best to use the
:meth:`Column.create_csindex` method instead.
Parameters
----------
optlevel : int
... | def create_index(self, optlevel=6, kind="medium", filters=None,
tmp_dir=None, _blocksizes=None, _testmode=False,
_verbose=False):
"""Create an index for this column.
.. warning::
In some situations it is useful to get a completely sorted
index (CSI). For those ... | (self, optlevel=6, kind='medium', filters=None, tmp_dir=None, _blocksizes=None, _testmode=False, _verbose=False) | [
0.023460963740944862,
-0.005052615888416767,
0.027361564338207245,
0.005564091727137566,
0.023193275555968285,
-0.007160661276429892,
-0.048681024461984634,
0.030573824420571327,
-0.09682667255401611,
-0.060765236616134644,
0.03009580820798874,
0.03151073306798935,
-0.02759101241827011,
-0... |
728,180 | tables.table | reindex | Recompute the index associated with this column.
This can be useful when you suspect that, for any reason,
the index information is no longer valid and you want to rebuild it.
This method does nothing if the column is not indexed.
| def reindex(self):
"""Recompute the index associated with this column.
This can be useful when you suspect that, for any reason,
the index information is no longer valid and you want to rebuild it.
This method does nothing if the column is not indexed.
"""
self._do_reindex(dirty=False)
| (self) | [
0.03646644949913025,
0.04511488974094391,
0.035206638276576996,
0.042663365602493286,
0.03827104717493057,
-0.020974168553948402,
-0.032959405332803726,
0.002166365971788764,
0.030388709157705307,
-0.08805064857006073,
0.002713277470320463,
-0.005928777623921633,
0.051107510924339294,
0.00... |
728,181 | tables.table | reindex_dirty | Recompute the associated index only if it is dirty.
This can be useful when you have set :attr:`Table.autoindex` to false
for the table and you want to update the column's index after an
invalidating index operation (like :meth:`Table.remove_rows`).
This method does nothing if the colu... | def reindex_dirty(self):
"""Recompute the associated index only if it is dirty.
This can be useful when you have set :attr:`Table.autoindex` to false
for the table and you want to update the column's index after an
invalidating index operation (like :meth:`Table.remove_rows`).
This method does nothi... | (self) | [
0.050528716295957565,
0.05228440463542938,
0.012430274859070778,
0.05720033124089241,
0.034130584448575974,
-0.023333100602030754,
-0.03244512528181076,
0.008804777637124062,
0.013861160725355148,
-0.09326217323541641,
-0.004121478646993637,
-0.013299340382218361,
0.05512861907482147,
-0.0... |
728,182 | tables.table | remove_index | Remove the index associated with this column.
This method does nothing if the column is not indexed. The removed
index can be created again by calling the :meth:`Column.create_index`
method.
| def remove_index(self):
"""Remove the index associated with this column.
This method does nothing if the column is not indexed. The removed
index can be created again by calling the :meth:`Column.create_index`
method.
"""
self._table_file._check_writable()
# Remove the index if existing.
... | (self) | [
0.04357977584004402,
0.04555414617061615,
0.02293861284852028,
0.028305314481258392,
0.048174675554037094,
-0.03656177967786789,
-0.04139001667499542,
0.035897672176361084,
-0.037261784076690674,
-0.0675235241651535,
0.012312902137637138,
0.03426432982087135,
0.01577702723443508,
-0.045625... |
728,183 | tables.atom | _ComplexErrorAtom | Reminds the user to stop using the old complex atom names. | class _ComplexErrorAtom(ComplexAtom, metaclass=type):
"""Reminds the user to stop using the old complex atom names."""
def __init__(self, shape=(), dflt=ComplexAtom._defvalue):
raise TypeError(
"to avoid confusions with PyTables 1.X complex atom names, "
"please use ``ComplexAto... | (shape=(), dflt=0j) | [
0.016948383301496506,
0.03715056926012039,
0.050380319356918335,
0.03182291239500046,
-0.007254015188664198,
-0.052382662892341614,
-0.022848136723041534,
-0.004308607894927263,
-0.016867931932210922,
-0.040475886315107346,
0.012559323571622372,
0.048270709812641144,
-0.043121837079524994,
... |
728,185 | tables.atom | __init__ | null | def __init__(self, shape=(), dflt=ComplexAtom._defvalue):
raise TypeError(
"to avoid confusions with PyTables 1.X complex atom names, "
"please use ``ComplexAtom(itemsize=N)``, "
"where N=8 for single precision complex atoms, "
"and N=16 for double precision complex atoms")
| (self, shape=(), dflt=0j) | [
0.03047272562980652,
0.04250333085656166,
0.05255284532904625,
-0.0058712223544716835,
0.003361094743013382,
-0.014569996856153011,
-0.01508327852934599,
-0.0052273692563176155,
-0.048878829926252365,
-0.0009792875498533249,
0.0039036425296217203,
0.06613229960203171,
-0.06094545125961304,
... |
728,191 | tables.description | Complex128Col | 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 Complex128Col
| (*args, **kwargs) | [
0.012736569158732891,
-0.008419016376137733,
0.06908084452152252,
0.04816677048802376,
0.02613411657512188,
-0.010872267186641693,
-0.019490424543619156,
-0.039285916835069656,
0.010253658518195152,
0.002995593473315239,
0.002709592692553997,
0.05131913721561432,
-0.016134681180119514,
0.0... |
728,207 | tables.description | Complex256Col | 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 Complex256Col
| (*args, **kwargs) | [
0.01111393142491579,
-0.03866739571094513,
0.017516430467367172,
0.036782823503017426,
0.008665669709444046,
-0.02481915056705475,
-0.004135122988373041,
-0.012367509305477142,
-0.014672745019197464,
-0.011719686910510063,
0.008581536822021008,
0.06979650259017944,
-0.028588296845555305,
0... |
728,223 | tables.description | Complex32Col | 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 Complex32Col
| (*args, **kwargs) | [
0.00005568741471506655,
-0.01912097819149494,
0.035394150763750076,
0.031970005482435226,
0.016561344265937805,
-0.01895146630704403,
-0.004199665039777756,
-0.0185615886002779,
-0.028800126165151596,
-0.012755794450640678,
-0.008619696833193302,
0.034038055688142776,
-0.028071222826838493,
... |
728,239 | tables.description | Complex64Col | 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 Complex64Col
| (*args, **kwargs) | [
0.012806764803826809,
-0.003154059173539281,
0.07375901192426682,
0.059908486902713776,
0.018837375566363335,
-0.03255536034703255,
-0.015465866774320602,
-0.030136486515402794,
-0.024337822571396828,
0.0008563384762965143,
0.007235904689878225,
0.05576658248901367,
-0.02551412396132946,
0... |
728,247 | tables.atom | ComplexAtom | Defines an atom of kind complex.
Allowed item sizes are 8 (single precision) and 16 (double precision). This
class must be used instead of more concrete ones to avoid confusions with
numarray-like precision specifications used in PyTables 1.X.
| class ComplexAtom(Atom):
"""Defines an atom of kind complex.
Allowed item sizes are 8 (single precision) and 16 (double precision). This
class must be used instead of more concrete ones to avoid confusions with
numarray-like precision specifications used in PyTables 1.X.
"""
# This definition... | (itemsize, shape=(), dflt=0j) | [
0.03921488672494888,
0.011849869973957539,
0.01891353167593479,
0.04932108148932457,
0.024162348359823227,
-0.026172911748290062,
-0.021475665271282196,
-0.024233518168330193,
-0.06508532166481018,
-0.023966629058122635,
0.018148450180888176,
0.04188377410173416,
-0.03683067858219147,
0.02... |
728,249 | tables.atom | __init__ | null | def __init__(self, itemsize, shape=(), dflt=_defvalue):
if itemsize not in self._isizes:
raise _invalid_itemsize_error('complex', itemsize, self._isizes)
self.type = '%s%d' % (self.kind, itemsize * 8)
Atom.__init__(self, self.type, shape, dflt)
| (self, itemsize, shape=(), dflt=0j) | [
0.043593764305114746,
0.010773376561701298,
0.015177419409155846,
0.00030763528775423765,
0.028175149112939835,
-0.015338215976953506,
-0.0075708432123064995,
-0.03955598175525665,
-0.052669841796159744,
-0.009897928684949875,
0.011997218243777752,
0.07639628648757935,
-0.044630009680986404,... |
728,255 | tables.description | ComplexCol | 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 ComplexCol
| (*args, **kwargs) | [
0.007774178870022297,
-0.01799539476633072,
0.038513507694005966,
0.016649944707751274,
0.009771331213414669,
-0.03773987665772438,
0.030978988856077194,
0.008938834071159363,
-0.037807147949934006,
-0.0121006416156888,
-0.01913902722299099,
0.028775813058018684,
-0.026909001171588898,
0.0... |
728,263 | tables.exceptions | DataTypeWarning | Unsupported data type.
This warning is issued when an unsupported HDF5 data type is found
(normally in a file created with other tool than PyTables).
| class DataTypeWarning(Warning):
"""Unsupported data type.
This warning is issued when an unsupported HDF5 data type is found
(normally in a file created with other tool than PyTables).
"""
pass
| null | [
-0.007692481856793165,
-0.005633511580526829,
0.021922724321484566,
-0.04673225060105324,
0.027424631640315056,
-0.03207748010754585,
0.02645670250058174,
0.03936241194605827,
-0.048566218465566635,
-0.05386435240507126,
-0.0025132170412689447,
0.007573613431304693,
-0.0001663626462686807,
... |
728,264 | tables.description | Description | This class represents descriptions of the structure of tables.
An instance of this class is automatically bound to Table (see
:ref:`TableClassDescr`) objects when they are created. It provides a
browseable representation of the structure of the table, made of non-nested
(Col - see :ref:`ColClassDescr`... | class Description:
"""This class represents descriptions of the structure of tables.
An instance of this class is automatically bound to Table (see
:ref:`TableClassDescr`) objects when they are created. It provides a
browseable representation of the structure of the table, made of non-nested
(Col ... | (classdict, nestedlvl=-1, validate=True, ptparams=None) | [
0.07352636009454727,
-0.029540088027715683,
0.00923986453562975,
0.011973058804869652,
0.0174787025898695,
-0.062220651656389236,
0.0389222577214241,
0.008547979407012463,
-0.01330776046961546,
-0.025830402970314026,
-0.05864836275577545,
0.015241115354001522,
0.003282777266576886,
0.00790... |
728,265 | tables.description | __init__ | null | def __init__(self, classdict, nestedlvl=-1, validate=True, ptparams=None):
if not classdict:
raise ValueError("cannot create an empty data type")
# Do a shallow copy of classdict just in case this is going to
# be shared by other instances
newdict = self.__dict__
newdict["_v_name"] = "/" #... | (self, classdict, nestedlvl=-1, validate=True, ptparams=None) | [
0.059959884732961655,
-0.005909793544560671,
0.02369862049818039,
0.031267911195755005,
-0.01273107249289751,
-0.05468912422657013,
0.011482734233140945,
-0.006851001642644405,
-0.03828238695859909,
-0.01051180437207222,
-0.02994031272828579,
0.013503854162991047,
-0.006870816461741924,
-0... |
728,266 | tables.description | __repr__ | Gives a detailed Description column representation. | def __repr__(self):
"""Gives a detailed Description column representation."""
rep = ['%s\"%s\": %r' %
(" " * self._v_nestedlvl, k, self._v_colobjects[k])
for k in self._v_names]
return '{\n %s}' % (',\n '.join(rep))
| (self) | [
0.040085285902023315,
-0.05279354751110077,
0.050272900611162186,
-0.02324596419930458,
0.019517507404088974,
-0.07449911534786224,
0.03110548108816147,
-0.02256328985095024,
0.041520655155181885,
-0.026834385469555855,
-0.05209336802363396,
0.03479892760515213,
-0.02312343381345272,
0.025... |
728,267 | tables.description | __str__ | Gives a brief Description representation. | def __str__(self):
"""Gives a brief Description representation."""
return f'Description({self._v_nested_descr})'
| (self) | [
0.02660737931728363,
-0.033701490610837936,
0.04667459800839424,
-0.008988255634903908,
0.046138517558574677,
-0.0881313607096672,
0.03371935710310936,
-0.026750333607196808,
0.06375764310359955,
-0.02635720930993557,
-0.06164906546473503,
0.01269613392651081,
-0.03168226033449173,
0.00448... |
728,268 | tables.description | _f_walk | Iterate over nested columns.
If type is 'All' (the default), all column description objects (Col and
Description instances) are yielded in top-to-bottom order (preorder).
If type is 'Col' or 'Description', only column descriptions of that
type are yielded.
| def _f_walk(self, type='All'):
"""Iterate over nested columns.
If type is 'All' (the default), all column description objects (Col and
Description instances) are yielded in top-to-bottom order (preorder).
If type is 'Col' or 'Description', only column descriptions of that
type are yielded.
"""
... | (self, type='All') | [
0.03693458065390587,
-0.006493106484413147,
-0.011499515734612942,
-0.01441021915525198,
-0.010003861971199512,
-0.04990288242697716,
0.052374742925167084,
-0.026939675211906433,
-0.033459652215242386,
-0.004106330219656229,
-0.016604440286755562,
-0.0072454116307199,
-0.006421458441764116,
... |
728,269 | tables.description | _g_set_nested_names_descr | Computes the nested names and descriptions for nested datatypes. | def _g_set_nested_names_descr(self):
"""Computes the nested names and descriptions for nested datatypes."""
names = self._v_names
fmts = self._v_nested_formats
self._v_nested_names = names[:] # Important to do a copy!
self._v_nested_descr = list(zip(names, fmts))
for i, name in enumerate(names)... | (self) | [
0.03009609691798687,
-0.003923584241420031,
0.0208209790289402,
0.017266390845179558,
0.007502189837396145,
-0.05502188205718994,
0.05089960992336273,
0.002705242484807968,
0.04834938794374466,
-0.01558079943060875,
-0.04565943032503128,
0.002698692260310054,
-0.028978191316127777,
-0.0446... |
728,270 | tables.description | _g_set_path_names | Compute the pathnames for arbitrary nested descriptions.
This method sets the ``_v_pathname`` and ``_v_pathnames``
attributes of all the elements (both descriptions and columns)
in this nested description.
| def _g_set_path_names(self):
"""Compute the pathnames for arbitrary nested descriptions.
This method sets the ``_v_pathname`` and ``_v_pathnames``
attributes of all the elements (both descriptions and columns)
in this nested description.
"""
def get_cols_in_order(description):
return [de... | (self) | [
0.0192435160279274,
-0.024449937045574188,
-0.01889396831393242,
0.029913919046521187,
-0.01076238788664341,
-0.03202960267663002,
0.04798001050949097,
0.04511004313826561,
0.01797410659492016,
-0.002416937844827771,
-0.006347049027681351,
0.014598213136196136,
-0.0034540824126452208,
0.00... |
728,271 | tables.earray | EArray | This class represents extendable, homogeneous datasets in an HDF5 file.
The main difference between an EArray and a CArray (see
:ref:`CArrayClassDescr`), from which it inherits, is that the former
can be enlarged along one of its dimensions, the *enlargeable
dimension*. That means that the :attr:`Leaf... | class EArray(CArray):
"""This class represents extendable, homogeneous datasets in an HDF5 file.
The main difference between an EArray and a CArray (see
:ref:`CArrayClassDescr`), from which it inherits, is that the former
can be enlarged along one of its dimensions, the *enlargeable
dimension*. Th... | (parentnode, name, atom=None, shape=None, title='', filters=None, expectedrows=None, chunkshape=None, byteorder=None, _log=True, track_times=True) | [
0.03963330760598183,
-0.021079104393720627,
-0.03599897772073746,
0.04686370864510536,
0.01816207729279995,
-0.018688099458813667,
-0.05095710977911949,
-0.02876857854425907,
-0.041240062564611435,
-0.06205137446522713,
0.019338451325893402,
-0.06277824193239212,
0.01601017266511917,
0.025... |
728,274 | tables.earray | __init__ | null | def __init__(self, parentnode, name,
atom=None, shape=None, title="",
filters=None, expectedrows=None,
chunkshape=None, byteorder=None,
_log=True, track_times=True):
# Specific of EArray
if expectedrows is None:
expectedrows = parentnode._v_file.params... | (self, parentnode, name, atom=None, shape=None, title='', filters=None, expectedrows=None, chunkshape=None, byteorder=None, _log=True, track_times=True) | [
-0.003563840640708804,
-0.0038859830237925053,
-0.02175249345600605,
0.012831628322601318,
-0.038098402321338654,
0.0011387619888409972,
-0.048118606209754944,
-0.0002621630555950105,
0.03388126567006111,
-0.033178411424160004,
0.03397137671709061,
-0.02427556738257408,
0.006177023518830538,... |
728,284 | tables.earray | _check_shape_append | Test that nparr shape is consistent with underlying EArray. | def _check_shape_append(self, nparr):
"""Test that nparr shape is consistent with underlying EArray."""
# Does the array conform to self expandibility?
myrank = len(self.shape)
narank = len(nparr.shape) - len(self.atom.shape)
if myrank != narank:
raise ValueError(("the ranks of the appended ... | (self, nparr) | [
-0.023601878434419632,
-0.005459027364850044,
-0.055315811187028885,
0.06507125496864319,
0.007570084184408188,
-0.01478176936507225,
-0.02965095266699791,
-0.021538900211453438,
-0.00789788831025362,
-0.013129637576639652,
0.03503567725419998,
-0.048952046781778336,
0.053008072078228,
-0.... |
728,301 | tables.earray | _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."""
(start, stop, step) = self._process_range_read(start, stop, step)
# Build the new EArray object
maindim = self.maindim... | (self, group, name, start, stop, step, title, filters, chunkshape, _log, **kwargs) | [
0.01740548200905323,
-0.009331686422228813,
-0.02804630622267723,
0.032761067152023315,
-0.02033124305307865,
-0.01003517396748066,
-0.021300284191966057,
-0.01896153949201107,
-0.04945840314030647,
-0.03678631782531738,
0.023070650175213814,
-0.035556379705667496,
0.00981154851615429,
0.0... |
728,302 | tables.earray | _g_create | Create a new array in file (specific part). | def _g_create(self):
"""Create a new array in file (specific part)."""
# Pre-conditions and extdim computation
zerodims = np.sum(np.array(self.shape) == 0)
if zerodims > 0:
if zerodims == 1:
self.extdim = list(self.shape).index(0)
else:
raise NotImplementedError(
... | (self) | [
0.043557461351156235,
0.01053894404321909,
-0.023215461522340775,
0.031976014375686646,
0.023092813789844513,
-0.007468370255082846,
-0.06882289052009583,
-0.012799166142940521,
-0.04874370992183685,
-0.016119414940476418,
0.05820510536432266,
0.0006608741241507232,
0.0015287162968888879,
... |
728,333 | tables.earray | append | Add a sequence of data to the end of the dataset.
The sequence must have the same type as the array; otherwise a
TypeError is raised. In the same way, the dimensions of the
sequence must conform to the shape of the array, that is, all
dimensions must match, with the exception of the enl... | def append(self, sequence):
"""Add a sequence of data to the end of the dataset.
The sequence must have the same type as the array; otherwise a
TypeError is raised. In the same way, the dimensions of the
sequence must conform to the shape of the array, that is, all
dimensions must match, with the ex... | (self, sequence) | [
-0.0078623341396451,
0.046114202588796616,
-0.03391358256340027,
0.06455299258232117,
0.04118570312857628,
0.001926810247823596,
-0.09822531789541245,
-0.013742928393185139,
0.012571117840707302,
-0.0361882746219635,
-0.00018982689653057605,
-0.06303653120994568,
0.03134594112634659,
0.025... |
728,348 | tables.misc.enum | Enum | Enumerated type.
Each instance of this class represents an enumerated type. The
values of the type must be declared
*exhaustively* and named with
*strings*, and they might be given explicit
concrete values, though this is not compulsory. Once the type is
defined, it can not be modified.
Th... | class Enum:
"""Enumerated type.
Each instance of this class represents an enumerated type. The
values of the type must be declared
*exhaustively* and named with
*strings*, and they might be given explicit
concrete values, though this is not compulsory. Once the type is
defined, it can not b... | (enum) | [
0.08125893026590347,
-0.03339754790067673,
-0.08071073889732361,
-0.047777045518159866,
0.022623464465141296,
-0.021390032023191452,
0.009076795540750027,
-0.04541560262441635,
0.01033658254891634,
-0.1021323949098587,
-0.04290657117962837,
0.03464152291417122,
0.056463781744241714,
0.0177... |
728,349 | tables.misc.enum | __call__ | Get the name of the enumerated value with that concrete value.
If there is no value with that concrete value in the enumeration and a
second argument is given as a default, this is returned. Else, a
ValueError is raised.
This method can be used for checking that a concrete value belong... | def __call__(self, value, *default):
"""Get the name of the enumerated value with that concrete value.
If there is no value with that concrete value in the enumeration and a
second argument is given as a default, this is returned. Else, a
ValueError is raised.
This method can be used for checking th... | (self, value, *default) | [
0.06399226933717728,
-0.06767846643924713,
-0.02641155757009983,
-0.01286480575799942,
0.006372502539306879,
-0.04040065035223961,
0.06366051733493805,
-0.06443461775779724,
0.05359721556305885,
-0.07387126237154007,
-0.003875108202919364,
0.05569834262132645,
0.016099438071250916,
-0.0338... |
728,350 | tables.misc.enum | __contains__ | Is there an enumerated value with that name in the type?
If the enumerated type has an enumerated value with that name, True is
returned. Otherwise, False is returned. The name must be a string.
This method does *not* check for concrete values matching a value in an
enumerated type. F... | def __contains__(self, name):
"""Is there an enumerated value with that name in the type?
If the enumerated type has an enumerated value with that name, True is
returned. Otherwise, False is returned. The name must be a string.
This method does *not* check for concrete values matching a value in an
... | (self, name) | [
0.04881895333528519,
-0.07150394469499588,
-0.06730829179286957,
-0.01950269192457199,
0.002522283000871539,
-0.010293581523001194,
0.02040938101708889,
-0.06353931128978729,
0.0015089252265170217,
-0.08633097261190414,
-0.02725399099290371,
0.029191814363002777,
0.05361906811594963,
-0.01... |
728,351 | tables.misc.enum | __delattr__ | This operation is forbidden. | def __delattr__(self, name):
"""This operation is forbidden."""
raise AttributeError("operation not allowed")
| (self, name) | [
0.04131689295172691,
0.011735470965504646,
0.017661798745393753,
0.02095978520810604,
-0.03385038673877716,
-0.04774545133113861,
-0.001564241130836308,
0.01186939887702465,
0.020407330244779587,
0.028007764369249344,
0.0031012780964374542,
0.0054199122823774815,
0.05484365299344063,
0.009... |
728,352 | tables.misc.enum | __delitem__ | This operation is forbidden. | def __delitem__(self, name):
"""This operation is forbidden."""
raise IndexError("operation not allowed")
| (self, name) | [
0.01536888349801302,
-0.012400279752910137,
-0.03340102732181549,
-0.013528349809348583,
-0.03241714835166931,
-0.04037300497293472,
-0.027989689260721207,
0.013485941104590893,
0.05675969645380974,
-0.01229849923402071,
0.0022646202705800533,
0.009524975903332233,
0.025496061891317368,
-0... |
728,353 | tables.misc.enum | __eq__ | Is the other enumerated type equivalent to this one?
Two enumerated types are equivalent if they have exactly the same
enumerated values (i.e. with the same names and concrete values).
Examples
--------
Let ``enum*`` be enumerated types defined as:
>>> enum1 = Enum({'... | def __eq__(self, other):
"""Is the other enumerated type equivalent to this one?
Two enumerated types are equivalent if they have exactly the same
enumerated values (i.e. with the same names and concrete values).
Examples
--------
Let ``enum*`` be enumerated types defined as:
>>> enum1 = Enu... | (self, other) | [
0.04339948669075966,
-0.05707179382443428,
-0.051976751536130905,
-0.012875059619545937,
-0.020710060372948647,
-0.07638896256685257,
-0.01369063276797533,
-0.014029690995812416,
0.0023482092656195164,
-0.03231135755777359,
-0.01611902378499508,
-0.04438917338848114,
0.06282662600278854,
0... |
728,354 | tables.misc.enum | __getattr__ | Get the concrete value of the enumerated value with that name.
The name of the enumerated value must be a string. If there is no value
with that name in the enumeration, an AttributeError is raised.
Examples
--------
Let ``enum`` be an enumerated type defined as:
>>> e... | def __getattr__(self, name):
"""Get the concrete value of the enumerated value with that name.
The name of the enumerated value must be a string. If there is no value
with that name in the enumeration, an AttributeError is raised.
Examples
--------
Let ``enum`` be an enumerated type defined as:
... | (self, name) | [
0.06844141334295273,
-0.05121392756700516,
-0.03932047262787819,
-0.02185872383415699,
0.009181384928524494,
-0.05096163973212242,
0.057809386402368546,
-0.06559418886899948,
0.015245242975652218,
-0.03950067609548569,
-0.027877531945705414,
0.07561352103948593,
0.03357197344303131,
0.0227... |
728,355 | tables.misc.enum | __getitem__ | Get the concrete value of the enumerated value with that name.
The name of the enumerated value must be a string. If there is no value
with that name in the enumeration, a KeyError is raised.
Examples
--------
Let ``enum`` be an enumerated type defined as:
>>> enum = ... | def __getitem__(self, name):
"""Get the concrete value of the enumerated value with that name.
The name of the enumerated value must be a string. If there is no value
with that name in the enumeration, a KeyError is raised.
Examples
--------
Let ``enum`` be an enumerated type defined as:
>>>... | (self, name) | [
0.06424065679311752,
-0.06195908039808273,
-0.0767180323600769,
-0.03634481132030487,
0.015971040353178978,
-0.03228075057268143,
0.013618163764476776,
-0.053224917501211166,
0.05928535759449005,
-0.07222617417573929,
-0.03718257695436478,
0.04705752804875374,
0.039785001426935196,
-0.0162... |
728,356 | tables.misc.enum | __init__ | null | def __init__(self, enum):
mydict = self.__dict__
mydict['_names'] = {}
mydict['_values'] = {}
if isinstance(enum, list) or isinstance(enum, tuple):
for (value, name) in enumerate(enum): # values become 0, 1, 2...
self._check_and_set_pair(name, value)
elif isinstance(enum, dict):... | (self, enum) | [
0.05882640928030014,
-0.011417207308113575,
-0.055181652307510376,
-0.02740858681499958,
-0.04184183478355408,
-0.03446119651198387,
-0.004847529344260693,
-0.0027130674570798874,
-0.021121378988027573,
-0.028574910014867783,
-0.02305310033261776,
0.09731506556272507,
0.009722394868731499,
... |
728,357 | tables.misc.enum | __iter__ | Iterate over the enumerated values.
Enumerated values are returned as (name, value) pairs *in no particular
order*.
Examples
--------
>>> enumvals = {'red': 4, 'green': 2, 'blue': 1}
>>> enum = Enum(enumvals)
>>> enumdict = dict([(name, value) for (name, value) ... | def __iter__(self):
"""Iterate over the enumerated values.
Enumerated values are returned as (name, value) pairs *in no particular
order*.
Examples
--------
>>> enumvals = {'red': 4, 'green': 2, 'blue': 1}
>>> enum = Enum(enumvals)
>>> enumdict = dict([(name, value) for (name, value) in ... | (self) | [
0.06105198711156845,
-0.06060824170708656,
-0.10819994658231735,
-0.06474986672401428,
-0.00979013554751873,
-0.02949058637022972,
-0.009485060349106789,
0.01097345631569624,
0.060460325330495834,
-0.03801419958472252,
-0.025367451831698418,
0.018369214609265327,
0.03329940140247345,
0.064... |
728,358 | tables.misc.enum | __len__ | Return the number of enumerated values in the enumerated type.
Examples
--------
>>> len(Enum(['e%d' % i for i in range(10)]))
10
| def __len__(self):
"""Return the number of enumerated values in the enumerated type.
Examples
--------
>>> len(Enum(['e%d' % i for i in range(10)]))
10
"""
return len(self._names)
| (self) | [
-0.02362089231610298,
-0.0714271143078804,
-0.0401606485247612,
-0.02861531637609005,
0.012126874178647995,
0.02497212402522564,
0.0071923136711120605,
-0.05818846821784973,
0.03441363945603371,
-0.05418608710169792,
-0.008748795837163925,
-0.001844045938923955,
0.030154693871736526,
-0.02... |
728,359 | tables.misc.enum | __ne__ | Is the `other` enumerated type different from this one?
Two enumerated types are different if they don't have exactly
the same enumerated values (i.e. with the same names and
concrete values).
Examples
--------
Let ``enum*`` be enumerated types defined as:
>>>... | def __ne__(self, other):
"""Is the `other` enumerated type different from this one?
Two enumerated types are different if they don't have exactly
the same enumerated values (i.e. with the same names and
concrete values).
Examples
--------
Let ``enum*`` be enumerated types defined as:
>>>... | (self, other) | [
0.03171020746231079,
-0.011911403387784958,
-0.021181775256991386,
-0.004670876078307629,
-0.06163593381643295,
-0.07794608175754547,
-0.023680048063397408,
-0.030800122767686844,
0.028640901669859886,
-0.03486873582005501,
-0.01879057288169861,
-0.03356606513261795,
0.02073565684258938,
0... |
728,360 | tables.misc.enum | __repr__ | Return the canonical string representation of the enumeration. The
output of this method can be evaluated to give a new enumeration object
that will compare equal to this one.
Examples
--------
>>> repr(Enum({'name': 10}))
"Enum({'name': 10})"
| def __repr__(self):
"""Return the canonical string representation of the enumeration. The
output of this method can be evaluated to give a new enumeration object
that will compare equal to this one.
Examples
--------
>>> repr(Enum({'name': 10}))
"Enum({'name': 10})"
"""
return 'Enum(... | (self) | [
0.030578188598155975,
-0.05883443355560303,
0.0003692222526296973,
-0.058477211743593216,
0.008220567367970943,
-0.07308758795261383,
-0.001723595312796533,
-0.05079694464802742,
0.049332331866025925,
-0.06980114430189133,
-0.054404884576797485,
0.0075105889700353146,
-0.009877183474600315,
... |
728,361 | tables.misc.enum | __setattr__ | This operation is forbidden. | def __setattr__(self, name, value):
"""This operation is forbidden."""
raise AttributeError("operation not allowed")
| (self, name, value) | [
0.04870619252324104,
-0.015510114841163158,
0.020707521587610245,
0.02755529060959816,
-0.026389364153146744,
-0.021479332819581032,
0.015534746460616589,
-0.005542259197682142,
0.03287585824728012,
-0.015411585569381714,
-0.0036866285372525454,
0.006884717382490635,
0.06752524524927139,
0... |
728,362 | tables.misc.enum | __setitem__ | This operation is forbidden. | def __setitem__(self, name, value):
"""This operation is forbidden."""
raise IndexError("operation not allowed")
| (self, name, value) | [
0.02520834654569626,
-0.01096726767718792,
-0.04612800106406212,
0.017613105475902557,
-0.03611014038324356,
-0.018005961552262306,
-0.033016387373209,
-0.0017473967745900154,
0.03719049692153931,
-0.04684824123978615,
-0.007938992232084274,
-0.007132816594094038,
0.03755061700940132,
-0.0... |
728,363 | tables.misc.enum | _check_and_set_pair | Check validity of enumerated value and insert it into type. | def _check_and_set_pair(self, name, value):
"""Check validity of enumerated value and insert it into type."""
names = self._names
values = self._values
if not isinstance(name, str):
raise TypeError(
f"name of enumerated value is not a string: {name!r}")
if name.startswith('_'):
... | (self, name, value) | [
0.039365097880363464,
0.0009418406989425421,
-0.09925628453493118,
-0.00007098128844518214,
-0.011089007370173931,
-0.007016301620751619,
0.02458561211824417,
-0.012284019030630589,
0.010799041017889977,
-0.06126193329691887,
-0.024216564372181892,
0.020649103447794914,
0.05911794304847717,
... |
728,364 | tables.atom | EnumAtom | Description of an atom of an enumerated type.
Instances of this class describe the atom type used to store enumerated
values. Those values belong to an enumerated type, defined by the first
argument (enum) in the constructor of the atom, which accepts the same
kinds of arguments as the Enum class (see ... | class EnumAtom(Atom):
"""Description of an atom of an enumerated type.
Instances of this class describe the atom type used to store enumerated
values. Those values belong to an enumerated type, defined by the first
argument (enum) in the constructor of the atom, which accepts the same
kinds of argu... | (enum, dflt, base, shape=()) | [
0.08096861094236374,
-0.03147225081920624,
-0.07065770030021667,
-0.011389956809580326,
0.042402613908052444,
-0.02739584445953369,
-0.0067140799947083,
-0.04296211898326874,
-0.03263122960925102,
-0.07001826167106628,
0.008027921430766582,
0.03524892032146454,
0.0077981241047382355,
0.035... |
728,366 | tables.atom | __init__ | null | def __init__(self, enum, dflt, base, shape=()):
if not isinstance(enum, Enum):
enum = Enum(enum)
self.enum = enum
if isinstance(base, str):
base = Atom.from_type(base)
self._checkbase(base)
self.base = base
default = enum[dflt] # check default value
self._defname = dflt # k... | (self, enum, dflt, base, shape=()) | [
0.045538995414972305,
-0.018174394965171814,
-0.04012877494096756,
-0.018523728474974632,
-0.004904130473732948,
-0.046972163021564484,
0.005979008506983519,
-0.03565011918544769,
-0.06277287006378174,
-0.026334509253501892,
0.0037710301112383604,
0.08570359647274017,
-0.014197345823049545,
... |
728,368 | tables.atom | __repr__ | null | def __repr__(self):
return ('EnumAtom(enum=%r, dflt=%r, base=%r, shape=%r)'
% (self.enum, self._defname, self.base, self.shape))
| (self) | [
0.03924278914928436,
-0.038619887083768845,
0.016307905316352844,
0.008002553135156631,
0.03609367460012436,
-0.06547385454177856,
0.02041732333600521,
-0.04142294451594353,
-0.030574077740311623,
-0.04650996997952461,
0.008331306278705597,
0.0174671933054924,
0.010944031178951263,
0.04332... |
728,369 | tables.atom | _checkbase | Check the `base` storage atom. | def _checkbase(self, base):
"""Check the `base` storage atom."""
if base.kind == 'enum':
raise TypeError("can not use an enumerated atom "
"as a storage atom: %r" % base)
# Check whether the storage atom can represent concrete values
# in the enumeration...
basedtype ... | (self, base) | [
0.011964441277086735,
-0.024451347067952156,
-0.06586538255214691,
0.060327257961034775,
0.01596129685640335,
-0.0024860610719770193,
-0.015673941001296043,
-0.04252862557768822,
-0.03967248648405075,
-0.06882601231336594,
0.028996789827942848,
0.07669781893491745,
0.01366245187819004,
-0.... |
728,370 | tables.atom | _get_init_args | Get a dictionary of instance constructor arguments. | def _get_init_args(self):
"""Get a dictionary of instance constructor arguments."""
return dict(enum=self.enum, dflt=self._defname,
base=self.base, shape=self.shape)
| (self) | [
0.017642056569457054,
-0.028133450075984,
0.0386999174952507,
-0.024642575532197952,
-0.009740667417645454,
0.020175756886601448,
0.04166528210043907,
0.0014991055941209197,
0.0105476975440979,
-0.0062216403894126415,
0.0007689074845984578,
0.047370798885822296,
-0.036447737365961075,
0.01... |
728,371 | tables.atom | _is_equal_to_atom | Is this object equal to the given `atom`? | def _is_equal_to_atom(self, atom):
"""Is this object equal to the given `atom`?"""
return False
| (self, atom) | [
0.07700390368700027,
0.012973105534911156,
0.0017944535939022899,
0.023685483261942863,
0.008642940782010555,
-0.06785664707422256,
-0.03349356725811958,
0.039371464401483536,
-0.011625363491475582,
-0.021824728697538376,
-0.006543071009218693,
-0.025250602513551712,
0.04257126525044441,
0... |
728,372 | tables.atom | _is_equal_to_enumatom | Is this object equal to the given `enumatom`? | def _is_equal_to_enumatom(self, enumatom):
"""Is this object equal to the given `enumatom`?"""
return (self.enum == enumatom.enum and self.shape == enumatom.shape
and np.all(self.dflt == enumatom.dflt)
and self.base == enumatom.base)
| (self, enumatom) | [
0.08001942187547684,
-0.042143095284700394,
-0.020704325288534164,
0.02736678160727024,
-0.011777333915233612,
-0.05469859018921852,
0.0012470247456803918,
-0.03324233368039131,
-0.03850584849715233,
-0.04126875847578049,
0.005923640448600054,
-0.021928399801254272,
0.047983672469854355,
0... |
728,374 | tables.description | EnumCol | 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 EnumCol
| (*args, **kwargs) | [
0.0334627628326416,
-0.05450529605150223,
-0.016543196514248848,
-0.03442079573869705,
-0.001800590893253684,
-0.03034915030002594,
0.04868866130709648,
-0.02213742956519127,
-0.04663573205471039,
-0.04160604998469353,
-0.019092250615358353,
0.026978924870491028,
-0.001049988204613328,
0.0... |
728,382 | tables.description | _is_equal_to_enumatom | Is this object equal to the given `enumatom`? | def same_position(oldmethod):
"""Decorate `oldmethod` to also compare the `_v_pos` attribute."""
def newmethod(self, other):
try:
other._v_pos
except AttributeError:
return False # not a column definition
return self._v_pos == other._v_pos and oldmethod(self, oth... | (self, other) | [
0.04642755538225174,
-0.05083077400922775,
0.035349052399396896,
0.04744910076260567,
-0.03719840571284294,
-0.04889335855841637,
0.008802036754786968,
0.04642755538225174,
0.04202433302998543,
-0.01743675209581852,
-0.02476371079683304,
-0.07580584287643433,
0.05773502215743065,
0.0286033... |
728,384 | tables.exceptions | ExperimentalFeatureWarning | Generic warning for experimental features.
This warning is issued when using a functionality that is still
experimental and that users have to use with care.
| class ExperimentalFeatureWarning(Warning):
"""Generic warning for experimental features.
This warning is issued when using a functionality that is still
experimental and that users have to use with care.
"""
pass
| null | [
-0.0001371950056636706,
-0.027505937963724136,
0.011049974709749222,
-0.029953930526971817,
0.05127188190817833,
-0.04331590235233307,
0.03447592258453369,
0.029205933213233948,
0.008873979561030865,
-0.020144954323768616,
0.00988547783344984,
-0.011806473135948181,
0.019821954891085625,
-... |
728,385 | tables.expression | Expr | A class for evaluating expressions with arbitrary array-like objects.
Expr is a class for evaluating expressions containing array-like objects.
With it, you can evaluate expressions (like "3 * a + 4 * b") that
operate on arbitrary large arrays while optimizing the resources
required to perform them (ba... | class Expr:
"""A class for evaluating expressions with arbitrary array-like objects.
Expr is a class for evaluating expressions containing array-like objects.
With it, you can evaluate expressions (like "3 * a + 4 * b") that
operate on arbitrary large arrays while optimizing the resources
required ... | (expr, uservars=None, **kwargs) | [
0.020983844995498657,
-0.059729449450969696,
0.017983276396989822,
0.003355502150952816,
0.0061622424982488155,
0.009323916397988796,
-0.04833131656050682,
-0.06589169055223465,
-0.015697607770562172,
-0.06508617103099823,
0.018990179523825645,
-0.0007249697227962315,
0.020389772951602936,
... |
728,386 | tables.expression | __init__ | null | def __init__(self, expr, uservars=None, **kwargs):
self.append_mode = False
"""The append mode for user-provided output containers."""
self.maindim = 0
"""Common main dimension for inputs in expression."""
self.names = []
"""The names of variables in expression (list)."""
self.out = None
... | (self, expr, uservars=None, **kwargs) | [
-0.014690931886434555,
-0.04118483513593674,
0.03413395956158638,
-0.016361892223358154,
-0.002941083861514926,
0.03471348434686661,
-0.04960724711418152,
-0.03817130997776985,
-0.03349648416042328,
-0.04578239098191261,
0.02802964113652706,
0.018670329824090004,
-0.032395388931035995,
0.0... |
728,387 | tables.expression | __iter__ | Iterate over the rows of the outcome of the expression.
This iterator always returns rows as NumPy objects, so a possible out
container specified in :meth:`Expr.set_output` method is ignored here.
| def __iter__(self):
"""Iterate over the rows of the outcome of the expression.
This iterator always returns rows as NumPy objects, so a possible out
container specified in :meth:`Expr.set_output` method is ignored here.
"""
values, shape, maindim = self.values, self.shape, self.maindim
# Get dif... | (self) | [
0.0025240189861506224,
-0.07817035168409348,
-0.03245962783694267,
0.021676868200302124,
-0.0108198756352067,
0.01888374425470829,
-0.015329703688621521,
-0.034835174679756165,
0.003779068822041154,
-0.046842824667692184,
0.01634116657078266,
-0.009929045103490353,
-0.0006542034680023789,
... |
728,388 | tables.expression | _calc_nrowsinbuf | Calculate the number of rows that will fit in a buffer. | def _calc_nrowsinbuf(self, object_):
"""Calculate the number of rows that will fit in a buffer."""
# Compute the rowsize for the *leading* dimension
shape_ = list(object_.shape)
if shape_:
shape_[0] = 1
rowsize = np.prod(shape_) * object_.dtype.itemsize
# Compute the nrowsinbuf
# Mul... | (self, object_) | [
-0.027114544063806534,
-0.021659651771187782,
-0.0517059788107872,
-0.003069487167522311,
0.018532417714595795,
0.020753465592861176,
0.0095593873411417,
0.02336541749536991,
-0.06382401287555695,
-0.0674842968583107,
0.0024698046036064625,
-0.026883555576205254,
-0.06353972107172012,
0.00... |
728,389 | tables.expression | _get_info | Return various info needed for evaluating the computation loop. | def _get_info(self, shape, maindim, itermode=False):
"""Return various info needed for evaluating the computation loop."""
# Compute the shape of the resulting container having
# in account new possible values of start, stop and step in
# the inputs range
if maindim is not None:
(start, stop... | (self, shape, maindim, itermode=False) | [
0.03778522461652756,
-0.055564168840646744,
-0.044507019221782684,
-0.011534437537193298,
0.03571698069572449,
0.03446410223841667,
-0.002707112580537796,
-0.05087084695696831,
-0.004936938174068928,
-0.03681076690554619,
-0.009943480603396893,
-0.03384760767221451,
-0.003746206406503916,
... |
728,390 | tables.expression | _guess_shape | Guess the shape of the output of the expression. | def _guess_shape(self):
"""Guess the shape of the output of the expression."""
# First, compute the maximum dimension of inputs and maindim
# (if it exists)
maxndim = 0
maindims = []
for val in self.values:
# Get the minimum of the lengths
if len(val.shape) > maxndim:
... | (self) | [
0.015331276692450047,
-0.06959668546915054,
0.012109207920730114,
-0.0042968932539224625,
0.020101862028241158,
0.012041880749166012,
0.010243292897939682,
-0.0401652529835701,
0.01735108159482479,
-0.025276407599449158,
0.002176098758354783,
0.03122040443122387,
-0.06917348504066467,
-0.0... |
728,391 | tables.expression | _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=2):
"""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=2) | [
0.01656585931777954,
-0.023742787539958954,
0.01801476813852787,
0.041458114981651306,
0.020130176097154617,
0.04775603860616684,
0.056604042649269104,
-0.05123342201113701,
-0.05258573591709137,
-0.058690473437309265,
0.03521814942359924,
0.0347738154232502,
-0.010789542458951473,
0.01080... |
728,392 | tables.expression | eval | Evaluate the expression and return the outcome.
Because of performance reasons, the computation order tries to go along
the common main dimension of all inputs. If not such a common main
dimension is found, the iteration will go along the leading dimension
instead.
For non-con... | def eval(self):
"""Evaluate the expression and return the outcome.
Because of performance reasons, the computation order tries to go along
the common main dimension of all inputs. If not such a common main
dimension is found, the iteration will go along the leading dimension
instead.
For non-co... | (self) | [
0.004556306172162294,
-0.05075734853744507,
-0.029497938230633736,
0.008349041454494,
0.008173218928277493,
0.03653082624077797,
-0.030161038041114807,
-0.051119040697813034,
-0.009856089018285275,
-0.060924895107746124,
0.021359883248806,
-0.004938091151416302,
-0.002667473629117012,
0.01... |
728,393 | tables.expression | set_inputs_range | Define a range for all inputs in expression.
The computation will only take place for the range defined by
the start, stop and step parameters in the main dimension of
inputs (or the leading one, if the object lacks the concept of
main dimension, like a NumPy container). If not a commo... | def set_inputs_range(self, start=None, stop=None, step=None):
"""Define a range for all inputs in expression.
The computation will only take place for the range defined by
the start, stop and step parameters in the main dimension of
inputs (or the leading one, if the object lacks the concept of
main... | (self, start=None, stop=None, step=None) | [
0.005835864692926407,
-0.007431311067193747,
0.0037664389237761497,
-0.039543379098176956,
-0.08308172225952148,
0.05399973317980766,
-0.01906071975827217,
-0.06496895849704742,
-0.0686592236161232,
-0.0018705236725509167,
0.046856194734573364,
-0.005069880746304989,
0.032535262405872345,
... |
728,394 | tables.expression | set_output | Set out as container for output as well as the append_mode.
The out must be a container that is meant to keep the outcome of
the expression. It should be an homogeneous type container and
can typically be an Array, CArray, EArray, Column or a NumPy ndarray.
The append_mode specifies t... | def set_output(self, out, append_mode=False):
"""Set out as container for output as well as the append_mode.
The out must be a container that is meant to keep the outcome of
the expression. It should be an homogeneous type container and
can typically be an Array, CArray, EArray, Column or a NumPy ndarr... | (self, out, append_mode=False) | [
0.01905142515897751,
-0.044637732207775116,
0.04774957895278931,
-0.026658164337277412,
0.012516544200479984,
0.045432981103658676,
-0.05639360100030899,
-0.003557015210390091,
0.00841063354164362,
-0.06092306971549988,
0.02359818108379841,
-0.017979566007852554,
0.029527980834245682,
0.02... |
728,395 | tables.expression | set_output_range | Define a range for user-provided output object.
The output object will only be modified in the range specified by the
start, stop and step parameters in the main dimension of output (or the
leading one, if the object does not have the concept of main dimension,
like a NumPy container).
... | def set_output_range(self, start=None, stop=None, step=None):
"""Define a range for user-provided output object.
The output object will only be modified in the range specified by the
start, stop and step parameters in the main dimension of output (or the
leading one, if the object does not have the conc... | (self, start=None, stop=None, step=None) | [
-0.006360116880387068,
0.018920717760920525,
-0.028717145323753357,
-0.06499585509300232,
-0.04365544021129608,
0.041034094989299774,
-0.04634399712085724,
0.00879662111401558,
-0.07050739973783493,
-0.057299863547086716,
0.037673402577638626,
0.015249157324433327,
0.02197895012795925,
-0.... |
728,396 | tables.file | File | The in-memory representation of a PyTables file.
An instance of this class is returned when a PyTables file is
opened with the :func:`tables.open_file` function. It offers methods
to manipulate (create, rename, delete...) nodes and handle their
attributes, as well as methods to traverse the object tree... | class File(hdf5extension.File):
"""The in-memory representation of a PyTables file.
An instance of this class is returned when a PyTables file is
opened with the :func:`tables.open_file` function. It offers methods
to manipulate (create, rename, delete...) nodes and handle their
attributes, as well... | (filename, mode='r', title='', root_uep='/', filters=None, **kwargs) | [
0.03151620179414749,
-0.028813056647777557,
-0.0251883864402771,
0.06385153532028198,
0.008447324857115746,
-0.02152276039123535,
-0.0463220588862896,
0.039789460599422455,
-0.047018323093652725,
-0.06401536613702774,
0.008897848427295685,
-0.02486073225736618,
-0.0011384689714759588,
0.05... |
728,397 | tables.file | __get_root_group | Returns a Group instance which will act as the root group in the
hierarchical tree.
If file is opened in "r", "r+" or "a" mode, and the file already
exists, this method dynamically builds a python object tree
emulating the structure present on file.
| def __get_root_group(self, root_uep, title, filters):
"""Returns a Group instance which will act as the root group in the
hierarchical tree.
If file is opened in "r", "r+" or "a" mode, and the file already
exists, this method dynamically builds a python object tree
emulating the structure present on... | (self, root_uep, title, filters) | [
0.0012555377325043082,
0.00672959117218852,
-0.030160224065184593,
0.03637075424194336,
-0.00016291825158987194,
-0.024659989401698112,
-0.002700032200664282,
0.0573335662484169,
-0.010745490901172161,
-0.018795501440763474,
0.018868353217840195,
-0.05216116085648537,
-0.03090694546699524,
... |
728,398 | tables.file | __contains__ | Is there a node with that path?
Returns True if the file has a node with the given path (a
string), False otherwise.
| def __contains__(self, path):
"""Is there a node with that path?
Returns True if the file has a node with the given path (a
string), False otherwise.
"""
try:
self.get_node(path)
except NoSuchNodeError:
return False
else:
return True
| (self, path) | [
0.04803270846605301,
-0.05768752470612526,
-0.009103111922740936,
0.024137040600180626,
-0.006504070479422808,
0.010706501081585884,
-0.0013835696736350656,
0.03522283956408501,
0.014189131557941437,
-0.00943930633366108,
0.028412744402885437,
-0.0011432768078520894,
0.06644582003355026,
-... |
728,399 | tables.file | __enter__ | Enter a context and return the same file. | def __enter__(self):
"""Enter a context and return the same file."""
return self
| (self) | [
0.040354855358600616,
-0.05021575838327408,
-0.0017217935528606176,
0.0075095826759934425,
0.02691408433020115,
-0.007879773154854774,
0.0032279815059155226,
0.03804421424865723,
0.012529531493782997,
-0.044553060084581375,
0.010064305737614632,
-0.05799382925033569,
-0.010707054287195206,
... |
728,400 | tables.file | __exit__ | Exit a context and close the file. | def __exit__(self, *exc_info):
"""Exit a context and close the file."""
self.close()
return False # do not hide exceptions
| (self, *exc_info) | [
0.04952080547809601,
-0.029736097902059555,
0.015930654481053352,
0.03334558382630348,
0.005304595921188593,
-0.07286439836025238,
-0.018958237022161484,
0.0695585161447525,
0.02071238122880459,
-0.028943359851837158,
0.018216099590063095,
-0.04884613677859306,
0.014547579921782017,
0.0114... |
728,401 | tables.file | __init__ | null | def __init__(self, filename, mode="r", title="",
root_uep="/", filters=None, **kwargs):
self.filename = os.fspath(filename)
"""The name of the opened file."""
self.mode = mode
"""The mode in which the file was opened."""
if mode not in ('r', 'r+', 'a', 'w'):
raise ValueError("in... | (self, filename, mode='r', title='', root_uep='/', filters=None, **kwargs) | [
0.017932740971446037,
-0.023828575387597084,
0.0158073790371418,
0.06911513209342957,
-0.017483144998550415,
-0.018658224493265152,
-0.050640832632780075,
0.046594470739364624,
-0.054687194526195526,
-0.03143083304166794,
0.018423208966851234,
-0.01564388908445835,
-0.02707792818546295,
0.... |
728,402 | tables.file | __iter__ | Recursively iterate over the nodes in the tree.
This is equivalent to calling :meth:`File.walk_nodes` with no
arguments.
Examples
--------
::
# Recursively list all the nodes in the object tree.
h5file = tables.open_file('vlarray1.h5')
prin... | def __iter__(self):
"""Recursively iterate over the nodes in the tree.
This is equivalent to calling :meth:`File.walk_nodes` with no
arguments.
Examples
--------
::
# Recursively list all the nodes in the object tree.
h5file = tables.open_file('vlarray1.h5')
print("All no... | (self) | [
0.0076202694326639175,
-0.08073265105485916,
-0.011836037039756775,
0.005308397114276886,
-0.019920557737350464,
0.01548438798636198,
-0.044080328196287155,
0.022377800196409225,
0.0452808141708374,
0.016750525683164597,
0.024647468701004982,
-0.027836259454488754,
0.023897165432572365,
0.... |
728,403 | tables.file | __repr__ | Return a detailed string representation of the object tree. | def __repr__(self):
"""Return a detailed string representation of the object tree."""
if not self.isopen:
return "<closed File>"
# Print all the nodes (Group and Leaf objects) on object tree
lines = [
f'File(filename={self.filename!s}, title={self.title!r}, '
f'mode={self.mode!r}... | (self) | [
0.017289068549871445,
-0.02380850724875927,
0.006663591600954533,
-0.0019460663897916675,
0.04493855684995651,
-0.04497575759887695,
0.002562204608693719,
-0.007012349087744951,
0.020665040239691734,
-0.03121146373450756,
-0.00753781059756875,
-0.0406232625246048,
-0.017884280532598495,
0.... |
728,404 | tables.file | __str__ | Return a short string representation of the object tree.
Examples
--------
::
>>> import tables
>>> f = tables.open_file('tables/tests/Tables_lzo2.h5')
>>> print(f)
tables/tests/Tables_lzo2.h5 (File) 'Table Benchmark'
Last modif.: '.... | def __str__(self):
"""Return a short string representation of the object tree.
Examples
--------
::
>>> import tables
>>> f = tables.open_file('tables/tests/Tables_lzo2.h5')
>>> print(f)
tables/tests/Tables_lzo2.h5 (File) 'Table Benchmark'
Last modif.: '...'
... | (self) | [
0.02185705676674843,
0.0035427906550467014,
-0.007113942410796881,
-0.008106585592031479,
0.06076866760849953,
-0.05449138209223747,
-0.014265700243413448,
0.02480662427842617,
-0.02630031667649746,
-0.0751761719584465,
-0.015371788293123245,
-0.009898070245981216,
-0.014483136124908924,
0... |
728,405 | tables.file | _check_group | null | def _check_group(self, node):
# `node` must already be a node.
if not isinstance(node, Group):
raise TypeError(f"node ``{node._v_pathname}`` is not a group")
| (self, node) | [
0.018031584098935127,
0.04357491061091423,
0.0056550512090325356,
0.0818474143743515,
-0.005306656006723642,
-0.04507046192884445,
0.03427870199084282,
0.08572225272655487,
0.05523340776562691,
-0.0005544584710150957,
0.06886331737041473,
-0.02372487261891365,
0.05730678513646126,
-0.02564... |
728,406 | tables.file | _check_open | Check the state of the file.
If the file is closed, a `ClosedFileError` is raised.
| def _check_open(self):
"""Check the state of the file.
If the file is closed, a `ClosedFileError` is raised.
"""
if not self.isopen:
raise ClosedFileError("the file object is closed")
| (self) | [
0.03160928934812546,
-0.04415716603398323,
0.0014198445715010166,
0.07148917764425278,
-0.00010544841643422842,
-0.06002392992377281,
0.03013620153069496,
0.04160144552588463,
-0.01033824309706688,
-0.05462852120399475,
0.03121883235871792,
-0.03851328417658806,
0.07553572952747345,
-0.017... |
728,407 | tables.file | _check_undo_enabled | null | def _check_undo_enabled(self):
if not self._undoEnabled:
raise UndoRedoError("Undo/Redo feature is currently disabled!")
| (self) | [
-0.050201915204524994,
0.018961399793624878,
0.032088521867990494,
0.03198676183819771,
0.03527702018618584,
0.01302536204457283,
-0.0069918036460876465,
0.02493135631084442,
0.00937045831233263,
0.02605072408914566,
0.05491682514548302,
0.006546601187437773,
0.023523667827248573,
-0.03339... |
728,408 | tables.file | _check_writable | Check whether the file is writable.
If the file is not writable, a `FileModeError` is raised.
| def _check_writable(self):
"""Check whether the file is writable.
If the file is not writable, a `FileModeError` is raised.
"""
if not self._iswritable():
raise FileModeError("the file is not writable")
| (self) | [
0.009417052380740643,
-0.0000061210776038933545,
-0.00669877277687192,
0.03780606389045715,
0.04728342592716217,
-0.033446475863456726,
0.023951880633831024,
0.03053434006869793,
-0.023366007953882217,
-0.03163716197013855,
0.06210257485508919,
0.006819393485784531,
0.07430252432823181,
0.... |
728,409 | tables.file | _create_mark | null | def _create_mark(self, trans, mid):
return MarkG(
trans, _markName % mid,
"Mark number %d" % mid, new=True)
| (self, trans, mid) | [
0.01936524361371994,
0.005868002772331238,
0.04277047514915466,
0.053588300943374634,
-0.0398990772664547,
0.0014847381971776485,
-0.01186955813318491,
0.06594198942184448,
0.03045017458498478,
-0.025208204984664917,
0.019515490159392357,
0.06110068038105965,
0.010517329908907413,
-0.01201... |
728,410 | tables.file | _create_path | Create the groups needed for the `path` to exist.
The group associated with the given `path` is returned.
| def _create_path(self, path):
"""Create the groups needed for the `path` to exist.
The group associated with the given `path` is returned.
"""
if not hasattr(path, 'split'):
raise TypeError("when creating parents, parent must be a path")
if path == '/':
return self.root
parent, c... | (self, path) | [
0.000994641799479723,
0.03751220554113388,
-0.051556363701820374,
0.005106133408844471,
-0.036430474370718,
0.05437986180186272,
0.05184971168637276,
0.07737120985984802,
0.05940349027514458,
-0.002470561768859625,
0.0772978737950325,
0.018618592992424965,
0.01622595265507698,
0.0039212722... |
728,411 | tables.file | _create_transaction | null | def _create_transaction(self, troot, tid):
return TransactionG(
troot, _trans_name % tid,
"Transaction number %d" % tid, new=True)
| (self, troot, tid) | [
0.008148826658725739,
0.039156585931777954,
0.06255202740430832,
-0.0006662424420937896,
-0.04091564193367958,
-0.004916561301797628,
-0.03016780875623226,
0.056852687150239944,
0.01898021250963211,
-0.06184840574860573,
0.004872584715485573,
0.07296563684940338,
-0.013588706962764263,
-0.... |
728,412 | tables.file | _create_transaction_group | null | def _create_transaction_group(self):
tgroup = TransactionGroupG(
self.root, _trans_group_name,
"Transaction information container", new=True)
# The format of the transaction container.
tgroup._v_attrs._g__setattr('FORMATVERSION', _trans_version)
return tgroup
| (self) | [
0.013821701519191265,
0.021879980340600014,
-0.008421777747571468,
-0.009144395589828491,
-0.0035824307706207037,
-0.025646351277828217,
-0.030411247164011,
0.03282872959971428,
-0.009538550861179829,
0.0056013804860413074,
0.022633254528045654,
0.015871306881308556,
-0.014224614948034286,
... |
728,413 | tables.file | _doundo | Undo/Redo actions up to final action in the specificed direction. | def _doundo(self, finalaction, direction):
"""Undo/Redo actions up to final action in the specificed direction."""
if direction < 0:
actionlog = \
self._actionlog[finalaction + 1:self._curaction + 1][::-1]
else:
actionlog = self._actionlog[self._curaction:finalaction]
# Uncom... | (self, finalaction, direction) | [
-0.07260417938232422,
0.03171656280755997,
-0.017996374517679214,
0.04934900999069214,
0.011745864525437355,
-0.04920343682169914,
-0.049931298941373825,
0.06663572043180466,
0.005718261934816837,
-0.08348571509122849,
0.00260892859660089,
0.04523659124970436,
0.021908629685640335,
0.01963... |
728,414 | tables.file | _get_final_action | Get the action to go.
It does not touch the self private attributes
| def _get_final_action(self, markid):
"""Get the action to go.
It does not touch the self private attributes
"""
if markid > self._nmarks - 1:
# The required mark is beyond the end of the action log
# The final action is the last row
return self._actionlog.nrows
elif markid <=... | (self, markid) | [
-0.006193126086145639,
0.05444272607564926,
0.01030117366462946,
0.05391036346554756,
0.012075708247721195,
-0.04670575261116028,
0.02874746173620224,
0.1005806252360344,
0.02509192004799843,
-0.0756661593914032,
-0.0038085950072854757,
0.05199386551976204,
0.0011889382731169462,
0.0149060... |
728,415 | tables.file | _get_mark_id | Get an integer markid from a mark sequence number or name. | def _get_mark_id(self, mark):
"""Get an integer markid from a mark sequence number or name."""
if isinstance(mark, int):
markid = mark
elif isinstance(mark, str):
if mark not in self._markers:
lmarkers = sorted(self._markers)
raise UndoRedoError("The mark that you hav... | (self, mark) | [
0.021183649078011513,
0.039737116545438766,
0.0342634879052639,
0.09497099369764328,
0.0012217918410897255,
0.015123561955988407,
0.013293095864355564,
0.11579921096563339,
0.0431847907602787,
-0.05704657360911369,
0.013346410356462002,
0.022605370730161667,
-0.0210237056016922,
-0.0164564... |
728,416 | tables.file | _get_node | null | def _get_node(self, nodepath):
# The root node is always at hand.
if nodepath == '/':
return self.root
node = self._node_manager.get_node(nodepath)
assert node is not None, "unable to instantiate node ``%s``" % nodepath
return node
| (self, nodepath) | [
0.013287692330777645,
-0.0050573223270475864,
0.03526793420314789,
0.019304927438497543,
0.01313659455627203,
0.0251710657030344,
0.06296321749687195,
0.08667663484811783,
0.0520130917429924,
0.014923100359737873,
0.05261748284101486,
0.04116962477564812,
-0.023411225527524948,
0.012843287... |
728,417 | tables.file | _get_or_create_path | Get the given `path` or create it if `create` is true.
If `create` is true, `path` *must* be a string path and not a
node, otherwise a `TypeError`will be raised.
| def _get_or_create_path(self, path, create):
"""Get the given `path` or create it if `create` is true.
If `create` is true, `path` *must* be a string path and not a
node, otherwise a `TypeError`will be raised.
"""
if create:
return self._create_path(path)
else:
return self.get_no... | (self, path, create) | [
0.01787409372627735,
-0.005303442943841219,
0.009081879630684853,
-0.0014632390812039375,
-0.012072254903614521,
-0.0027241380885243416,
0.030108220875263214,
0.09017131477594376,
0.056604139506816864,
-0.037179477512836456,
0.08349195867776871,
0.03663422539830208,
0.02777385525405407,
-0... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.