# Recordclass library
**Recordclass** is [MIT Licensed](http://opensource.org/licenses/MIT) python library.
It was started as a "proof of concept" for the problem of fast "mutable"
alternative of `namedtuple` (see [question](https://stackoverflow.com/questions/29290359/existence-of-mutable-named-tuple-in-python) on [stackoverflow](https://stackoverflow.com)).
It was evolved further in order to provide more memory saving, fast and flexible types.
**Recordclass** library provide record/data-like classes that do not participate in cyclic *garbage collection* (GC) mechanism by default, but support only *reference counting* for garbage collection.
The instances of such classes havn't `PyGC_Head` prefix in the memory, which decrease their size and have a little faster path for the instance creation and deallocation.
This may make sense in cases where it is necessary to limit the size of the objects as much as possible, provided that they will never be part of references cycles in the application.
For example, when an object represents a record with fields with values of simple types by convention (`int`, `float`, `str`, `date`/`time`/`datetime`, `timedelta`, etc.).
In order to illustrate this, consider a simple class with type hints:
class Point:
x: int
y: int
By tacit agreement instances of the class `Point` is supposed to have attributes `x` and `y` with values of `int` type. Assigning other types of values, which are not subclass of `int`, should be considered as a violation of the agreement.
Other examples are non-recursive data structures in which all leaf elements represent a value of an atomic type.
Of course, in python, nothing prevent you from “shooting yourself in the foot" by creating the reference cycle in the script or application code.
But in many cases, this can still be avoided provided that the developer understands what he is doing and uses such classes in the codebase with care.
Another option is to use static code analyzers along with type annotations to monitor compliance with typehints.
The library is built on top of the base class `dataobject`. The type of `dataobject` is special metaclass `datatype`.
It control creation of subclasses, which will not participate in cyclic GC and do not contain `PyGC_Head`-prefix, `__dict__` and `__weakref__` by default.
As the result the instance of such class need less memory.
It's memory footprint is similar to memory footprint of instances of the classes with `__slots__` but without `PyGC_Head`. So the difference in memory size is equal to the size of `PyGC_Head`.
It also tunes `basicsize` of the instances, creates descriptors for the fields and etc.
All subclasses of `dataobject` created by `class statement` support `attrs`/`dataclasses`-like API.
For example:
from recordclass import dataobject, astuple, asdict
class Point(dataobject):
x:int
y:int
>>> p = Point(1, 2)
>>> astuple(p)
(1, 2)
>>> asdict(p)
{'x':1, 'y':2}
The `recordclass` factory create dataobject-based subclass with specified fields and the support of `namedtuple`-like API.
By default it will not participate in cyclic GC too.
>>> from recordclass import recordclass
>>> Point = recordclass('Point', 'x y')
>>> p = Point(1, 2)
>>> p.y = -1
>>> print(p._astuple)
(1, -1)
>>> x, y = p
>>> print(p._asdict)
{'x':1, 'y':-1}
It also provide a factory function `make_dataclass` for creation of subclasses of `dataobject` with the specified field names.
These subclasses support `attrs`/`dataclasses`-like API. It's equivalent to creating subclasses of dataobject using `class statement`.
For example:
>>> Point = make_dataclass('Point', 'x y')
>>> p = Point(1, 2)
>>> p.y = -1
>>> print(p.x, p.y)
1 -1
If one want to use some sequence for initialization then:
>>> p = Point(*sequence)
There is also a factory function `make_arrayclass` for creation of the subclass of `dataobject`, which can be considered as a compact array of simple objects.
For example:
>>> Pair = make_arrayclass(2)
>>> p = Pair(2, 3)
>>> p[1] = -1
>>> print(p)
Pair(2, -1)
The library provide in addition the classes `lightlist` (immutable) and `litetuple`, which considers as list-like and tuple-like *light* containers in order to save memory. They do not supposed to participate in cyclic GC too. Mutable variant of litetuple is called by `mutabletuple`.
For example:
>>> lt = litetuple(1, 2, 3)
>>> mt = mutabletuple(1, 2, 3)
>>> lt == mt
True
>>> mt[-1] = -3
>>> lt == mt
False
>>> print(sys.getsizeof((1,2,3)), sys.getsizeof(litetuple(1,2,3)))
64 48
Note if one like create `litetuple` or `mutabletuple` from some iterable then:
>>> seq = [1,2,3]
>>> lt = litetuple(*seq)
>>> mt = mutabletuple(*seq)
### Memory footprint
The following table explain memory footprints of the `dataobject`-based objects and litetuples:
<table border="1" class="dataframe">
<thead>
<tr style="text-align: right;">
<th>tuple/namedtuple</th>
<th>class with __slots__</th>
<th>recordclass/dataobject</th>
<th>litetuple/mutabletuple</th>
</tr>
</thead>
<tbody>
<tr>
<td>g+b+s+n×p</td>
<td>g+b+n×p</td>
<td>b+n×p</td>
<td>b+s+n×p</td>
</tr>
</tbody>
</table>
where:
* b = sizeof(PyObject)
* s = sizeof(Py_ssize_t)
* n = number of items
* p = sizeof(PyObject*)
* g = sizeof(PyGC_Head)
This is useful in that case when you absolutely sure that reference cycle isn't supposed.
For example, when all field values are instances of atomic types.
As a result the size of the instance is decreased by 24-32 bytes for cpython 3.4-3.7 and by 16 bytes for cpython >=3.8.
### Performance counters
Here is the table with performance counters, which was measured using `tools/perfcounts.py` script:
* recordclass 0.21, python 3.10, debian/testing linux, x86-64:
<table border="1" class="dataframe">
<thead>
<tr style="text-align: right;">
<th>id</th>
<th>size</th>
<th>new</th>
<th>getattr</th>
<th>setattr</th>
<th>getitem</th>
<th>setitem</th>
<th>getkey</th>
<th>setkey</th>
<th>iterate</th>
<th>copy</th>
</tr>
</thead>
<tbody>
<tr>
<td>litetuple</td>
<td>48</td>
<td>0.18</td>
<td></td>
<td></td>
<td>0.2</td>
<td></td>
<td></td>
<td></td>
<td>0.33</td>
<td>0.19</td>
</tr>
<tr>
<td>mutabletuple</td>
<td>48</td>
<td>0.18</td>
<td></td>
<td></td>
<td>0.21</td>
<td>0.21</td>
<td></td>
<td></td>
<td>0.33</td>
<td>0.18</td>
</tr>
<tr>
<td>tuple</td>
<td>64</td>
<td>0.24</td>
<td></td>
<td></td>
<td>0.21</td>
<td></td>
<td></td>
<td></td>
<td>0.37</td>
<td>0.16</td>
</tr>
<tr>
<td>namedtuple</td>
<td>64</td>
<td>0.75</td>
<td>0.23</td>
<td></td>
<td>0.21</td>
<td></td>
<td></td>
<td></td>
<td>0.33</td>
<td>0.21</td>
</tr>
<tr>
<td>class+slots</td>
<td>56</td>
<td>0.68</td>
<td>0.29</td>
<td>0.33</td>
<td></td>
<td></td>
<td></td>
<td></td>
<td></td>
<td></td>
</tr>
<tr>
<td>dataobject</td>
<td>40</td>
<td>0.25</td>
<td>0.23</td>
<td>0.29</td>
<td>0.2</td>
<td>0.22</td>
<td></td>
<td></td>
<td>0.33</td>
<td>0.2</td>
</tr>
<tr>
<td>dataobject+gc</td>
<td>56</td>
<td>0.27</td>
<td>0.22</td>
<td>0.29</td>
<td>0.19</td>
<td>0.21</td>
<td></td>
<td></td>
<td>0.35</td>
<td>0.22</td>
</tr>
<tr>
<td>dict</td>
<td>232</td>
<td>0.32</td>
<td></td>
<td></td>
<td></td>
<td></td>
<td>0.2</td>
<td>0.24</td>
<td>0.35</td>
<td>0.25</td>
</tr>
<tr>
<td>dataobject+map</td>
<td>40</td>
<td>0.25</td>
<td>0.23</td>
<td>0.3</td>
<td></td>
<td></td>
<td>0.29</td>
<td>0.29</td>
<td>0.32</td>
<td>0.2</td>
</tr>
</tbody>
</table>
* recordclass 0.21, python 3.11, debian/testing linux, x86-64:
<table>
<thead>
<tr>
<th>id</th>
<th>size</th>
<th>new</th>
<th>getattr</th>
<th>setattr</th>
<th>getitem</th>
<th>setitem</th>
<th>getkey</th>
<th>setkey</th>
<th>iterate</th>
<th>copy</th>
</tr>
</thead>
<tbody>
<tr>
<td>litetuple</td>
<td>48</td>
<td>0.11</td>
<td> </td>
<td> </td>
<td>0.11</td>
<td> </td>
<td> </td>
<td> </td>
<td>0.18</td>
<td>0.09</td>
</tr>
<tr>
<td>mutabletuple</td>
<td>48</td>
<td>0.11</td>
<td> </td>
<td> </td>
<td>0.11</td>
<td>0.12</td>
<td> </td>
<td> </td>
<td>0.18</td>
<td>0.08</td>
</tr>
<tr>
<td>tuple</td>
<td>64</td>
<td>0.1</td>
<td> </td>
<td> </td>
<td>0.08</td>
<td> </td>
<td> </td>
<td> </td>
<td>0.17</td>
<td>0.1</td>
</tr>
<tr>
<td>namedtuple</td>
<td>64</td>
<td>0.49</td>
<td>0.13</td>
<td> </td>
<td>0.11</td>
<td> </td>
<td> </td>
<td> </td>
<td>0.17</td>
<td>0.13</td>
</tr>
<tr>
<td>class+slots</td>
<td>56</td>
<td>0.31</td>
<td>0.06</td>
<td>0.06</td>
<td> </td>
<td> </td>
<td> </td>
<td> </td>
<td> </td>
<td> </td>
</tr>
<tr>
<td>dataobject</td>
<td>40</td>
<td>0.13</td>
<td>0.06</td>
<td>0.06</td>
<td>0.11</td>
<td>0.12</td>
<td> </td>
<td> </td>
<td>0.16</td>
<td>0.12</td>
</tr>
<tr>
<td>dataobject+gc</td>
<td>56</td>
<td>0.14</td>
<td>0.06</td>
<td>0.06</td>
<td>0.1</td>
<td>0.12</td>
<td> </td>
<td> </td>
<td>0.16</td>
<td>0.14</td>
</tr>
<tr>
<td>dict</td>
<td>184</td>
<td>0.2</td>
<td> </td>
<td> </td>
<td> </td>
<td> </td>
<td>0.12</td>
<td>0.13</td>
<td>0.19</td>
<td>0.13</td>
</tr>
<tr>
<td>dataobject+map</td>
<td>40</td>
<td>0.12</td>
<td>0.07</td>
<td>0.06</td>
<td> </td>
<td> </td>
<td>0.15</td>
<td>0.16</td>
<td>0.16</td>
<td>0.12</td>
</tr>
<tr>
<td>class</td>
<td>56</td>
<td>0.35</td>
<td>0.06</td>
<td>0.06</td>
<td> </td>
<td> </td>
<td> </td>
<td> </td>
<td> </td>
<td> </td>
</tr>
</tbody>
</table>
* recordclas 0.21, python3.12, debian/testing linux, x86-64:
<table>
<thead>
<tr>
<th>id</th>
<th>size</th>
<th>new</th>
<th>getattr</th>
<th>setattr</th>
<th>getitem</th>
<th>setitem</th>
<th>getkey</th>
<th>setkey</th>
<th>iterate</th>
<th>copy</th>
</tr>
</thead>
<tbody>
<tr>
<td>litetuple</td>
<td>48</td>
<td>0.13</td>
<td> </td>
<td> </td>
<td>0.12</td>
<td> </td>
<td> </td>
<td> </td>
<td>0.19</td>
<td>0.09</td>
</tr>
<tr>
<td>mutabletuple</td>
<td>48</td>
<td>0.13</td>
<td> </td>
<td> </td>
<td>0.11</td>
<td>0.12</td>
<td> </td>
<td> </td>
<td>0.18</td>
<td>0.09</td>
</tr>
<tr>
<td>tuple</td>
<td>64</td>
<td>0.11</td>
<td> </td>
<td> </td>
<td>0.09</td>
<td> </td>
<td> </td>
<td> </td>
<td>0.16</td>
<td>0.09</td>
</tr>
<tr>
<td>namedtuple</td>
<td>64</td>
<td>0.52</td>
<td>0.13</td>
<td> </td>
<td>0.11</td>
<td> </td>
<td> </td>
<td> </td>
<td>0.16</td>
<td>0.12</td>
</tr>
<tr>
<td>class+slots</td>
<td>56</td>
<td>0.34</td>
<td>0.08</td>
<td>0.07</td>
<td> </td>
<td> </td>
<td> </td>
<td> </td>
<td> </td>
<td> </td>
</tr>
<tr>
<td>dataobject</td>
<td>40</td>
<td>0.14</td>
<td>0.08</td>
<td>0.08</td>
<td>0.11</td>
<td>0.12</td>
<td> </td>
<td> </td>
<td>0.17</td>
<td>0.12</td>
</tr>
<tr>
<td>dataobject+gc</td>
<td>56</td>
<td>0.15</td>
<td>0.08</td>
<td>0.07</td>
<td>0.12</td>
<td>0.12</td>
<td> </td>
<td> </td>
<td>0.17</td>
<td>0.13</td>
</tr>
<tr>
<td>dict</td>
<td>184</td>
<td>0.19</td>
<td> </td>
<td> </td>
<td> </td>
<td> </td>
<td>0.11</td>
<td>0.14</td>
<td>0.2</td>
<td>0.12</td>
</tr>
<tr>
<td>dataobject+map</td>
<td>40</td>
<td>0.14</td>
<td>0.08</td>
<td>0.08</td>
<td> </td>
<td> </td>
<td>0.16</td>
<td>0.17</td>
<td>0.17</td>
<td>0.12</td>
</tr>
<tr>
<td>class</td>
<td>48</td>
<td>0.41</td>
<td>0.08</td>
<td>0.08</td>
<td> </td>
<td> </td>
<td> </td>
<td> </td>
<td> </td>
<td> </td>
</tr>
</tbody>
</table>
Main repository for `recordclass` is on [github](https://github.com/intellimath/recordclass).
Here is also a simple [example](https://github.com/intellimath/recordclass/blob/main/examples/what_is_recordclass.ipynb).
More examples can be found in the folder [examples](https://github.com/intellimath/recordclass/tree/main/examples).
## Quick start
### Installation
#### Installation from directory with sources
Install:
>>> python3 setup.py install
Run tests:
>>> python3 test_all.py
#### Installation from PyPI
Install:
>>> pip3 install recordclass
Run tests:
>>> python3 -c "from recordclass.test import *; test_all()"
### Quick start with dataobject
`Dataobject` is the base class for creation of data classes with fast instance creation and small memory footprint. They provide `dataclass`-like API.
First load inventory:
>>> from recordclass import dataobject, asdict, astuple, as_dataclass, as_record
Define class one of the ways:
class Point(dataobject):
x: int
y: int
or
@as_dataclass()
class Point:
x: int
y: int
or
@as_record
def Point(x:int, y:int): pass
or
>>> Point = make_dataclass("Point", [("x",int), ("y",int)])
or
>>> Point = make_dataclass("Point", {"x":int, "y",int})
Annotations of the fields are defined as a dict in `__annotations__`:
>>> print(Point.__annotations__)
{'x': <class 'int'>, 'y': <class 'int'>}
There is default text representation:
>>> p = Point(1, 2)
>>> print(p)
Point(x=1, y=2)
The instances has a minimum memory footprint that is possible for CPython object, which contain only Python objects:
>>> sys.getsizeof(p) # the output below for python 3.8+ (64bit)
40
>>> p.__sizeof__() == sys.getsizeof(p) # no additional space for cyclic GC support
True
The instance is mutable by default:
>>> p_id = id(p)
>>> p.x, p.y = 10, 20
>>> id(p) == p_id
True
>>> print(p)
Point(x=10, y=20)
There are functions `asdict` and `astuple` for converting to `dict` and to `tuple`:
>>> asdict(p)
{'x':10, 'y':20}
>>> astuple(p)
(10, 20)
By default subclasses of dataobject are mutable. If one want make it immutable then there is the option `readonly=True`:
class Point(dataobject, readonly=True):
x: int
y: int
>>> p = Point(1,2)
>>> p.x = -1
. . . . . . . . . . . . .
TypeError: item is readonly
By default subclasses of dataobject are not iterable by default.
If one want make it iterable then there is the option `iterable=True`:
class Point(dataobject, iterable=True):
x: int
y: int
>>> p = Point(1,2)
>>> for x in p: print(x)
1
2
Default values are also supported::
class CPoint(dataobject):
x: int
y: int
color: str = 'white'
or
>>> CPoint = make_dataclass("CPoint", [("x",int), ("y",int), ("color",str)], defaults=("white",))
>>> p = CPoint(1,2)
>>> print(p)
Point(x=1, y=2, color='white')
But
class PointInvalidDefaults(dataobject):
x:int = 0
y:int
is not allowed. A fields without default value may not appear after a field with default value.
There is an option `copy_default` (starting from 0.21) in order to assign a copy of the default value when creating an instance:
class Polygon(dataobject, copy_default=True):
points: list = []
>>> pg1 = Polygon()
>>> pg2 = Polygon()
>>> assert pg1.points == pg2.points
True
>>> assert id(pg1.points) != id(pg2.points)
True
A `Factory` (starting from 0.21) allows you to setup a factory function to calculate the default value:
from recordclass import Factory
class A(dataobject, copy_default=True):
x: tuple = Factory( lambda: (list(), dict()) )
>>> a = A()
>>> b = A()
>>> assert a.x == b.x
True
>>> assert id(a.x[0]) != id(b.x[0])
True
>>> assert id(a.x[1]) != id(b.x[1])
True
If someone wants to define a class attribute, then there is a `ClassVar` trick:
class Point(dataobject):
x:int
y:int
color:ClassVar[int] = 0
>>> print(Point.__fields__)
('x', 'y')
>>> print(Point.color)
0
If the default value for the `ClassVar`-attribute is not specified,
it will just be excluded from the `__fields___`.
Starting with python 3.10 `__match_args__` is specified by default so that `__match_args__` == `__fields__`.
User can define it's own during definition:
class User(dataobject):
first_name: str
last_name: str
age: int
__match_args__ = 'first_name', 'last_name'
or
from recordclass import MATCH
class User(dataobject):
first_name: str
last_name: str
_: MATCH
age: int
or
User = make_dataclass("User", "first_name last_name * age")
### Quick start with recordclass
The `recordclass` factory function is designed to create classes that support `namedtuple`'s API, can be mutable and immutable, provide fast creation of the instances and have a minimum memory footprint.
First load inventory:
>>> from recordclass import recordclass
Example with `recordclass`:
>>> Point = recordclass('Point', 'x y')
>>> p = Point(1,2)
>>> print(p)
Point(1, 2)
>>> print(p.x, p.y)
1 2
>>> p.x, p.y = 1, 2
>>> print(p)
Point(1, 2)
>>> sys.getsizeof(p) # the output below is for 64bit cpython3.8+
32
Example with class statement and typehints:
>>> from recordclass import RecordClass
class Point(RecordClass):
x: int
y: int
>>> print(Point.__annotations__)
{'x': <class 'int'>, 'y': <class 'int'>}
>>> p = Point(1, 2)
>>> print(p)
Point(1, 2)
>>> print(p.x, p.y)
1 2
>>> p.x, p.y = 1, 2
>>> print(p)
Point(1, 2)
By default `recordclass`-based class instances doesn't participate in cyclic GC and therefore they are smaller than `namedtuple`-based ones. If one want to use it in scenarios with reference cycles then one have to use option `gc=True` (`gc=False` by default):
>>> Node = recordclass('Node', 'root children', gc=True)
or
class Node(RecordClass, gc=True):
root: 'Node'
chilren: list
The `recordclass` factory can also specify type of the fields:
>>> Point = recordclass('Point', [('x',int), ('y',int)])
or
>>> Point = recordclass('Point', {'x':int, 'y':int})
### Using dataobject-based classes with mapping protocol
class FastMapingPoint(dataobject, mapping=True):
x: int
y: int
or
FastMapingPoint = make_dataclass("FastMapingPoint", [("x", int), ("y", int)], mapping=True)
>>> p = FastMappingPoint(1,2)
>>> print(p['x'], p['y'])
1 2
>>> sys.getsizeof(p) # the output below for python 3.10 (64bit)
32
### Using dataobject-based classes for recursive data without reference cycles
There is the option `deep_dealloc` (default value is `False`) for deallocation of recursive datastructures.
Let consider simple example:
class LinkedItem(dataobject):
val: object
next: 'LinkedItem'
class LinkedList(dataobject, deep_dealloc=True):
start: LinkedItem = None
end: LinkedItem = None
def append(self, val):
link = LinkedItem(val, None)
if self.start is None:
self.start = link
else:
self.end.next = link
self.end = link
Without `deep_dealloc=True` deallocation of the instance of `LinkedList` will be failed if the length of the linked list is too large.
But it can be resolved with `__del__` method for clearing the linked list:
def __del__(self):
curr = self.start
while curr is not None:
next = curr.next
curr.next = None
curr = next
There is builtin more fast deallocation method using finalization mechanizm when `deep_dealloc=True`. In such case one don't need `__del__` method for clearing the linked list.
> Note that for classes with `gc=True` this method is disabled: the python's cyclic GC is used in these cases.
For more details see notebook [example_datatypes](https://github.com/intellimath/recordclass/tree/main/examples/example_datatypes.ipynb).
### Changes:
#### 0.22.1:
* Add `pyproject.toml`.
* Add `pytest.ini` in order to run `pytest`:
>>> pip3 install -e .
>>> pytest
#### 0.22.0.3:
* Rename `examples\test_*.py` files since they are detected by `pytest` as a tests.
* Fix segfault with `litelist` after `0.22.0.2`.
#### 0.22.0.2
* Make release on github with right tag.
#### 0.22.0.1
* Fix regression with `as_dataclass`.
#### 0.22
* Add a base class `datastruct` for subclasses that should behave more like simple datastructures.
* Fix bug with `__match_args__` (#6).
* Start support for python 3.13.
#### 0.21.1
* Allow to specify `__match_args__`. For example,
class User(dataobject):
first_name: str
last_name: str
age: int
__match_args__ = 'first_name', 'last_name'
or
User = make_dataclass("User", "first_name last_name * age")
* Add `@as_record` adapter for `def`-style decalarations of dataclasses
that are considered as just a struct. For example:
@as_record()
def Point(x:float, y:float, meta=None): pass
>>> p = Point(1,2)
>>> print(p)
Point(x=1, y=2, meta=None)
It's almost equivalent to:
Point = make_dataclass('Point', [('x':float), ('y',float),'meta'], (None,))
* The option `fast_new` will be removed in 0.22. It will be always as `fast_new=True` by creation.
One can specify own `__new__`, for example:
class Point(dataobject):
x:int
y:int
def __new__(cls, x=0, y=0):
return dataobject.__new__(cls, x, y)
* Fix issues with `_PyUnicodeWriter` for python3.13.
#### 0.21
* Add a new option `copy_default` (default `False`) to allow assigning a copy of the default
value for the field. For example:
class A(dataobject, copy_default=True):
l: list = []
a = A()
b = A()
assert(a.l == b.l)
assert(id(a.l) != id(b.l))
* Allow to inherit the options: `copy_default`, `gc`, `iterable`. For example:
class Base(dataobject, copy_default=True):
pass
class A(Base):
l: list = []
a = A()
b = A()
assert a.l == b.l
assert id(a.l) != id(b.l)
* Add `Factory` to specify factory function for default values. For example:
from recordclass import Factory
class A(dataobject):
x: tuple = Factory(lambda: (list(), dict()))
a = A()
b = A()
assert a.x == ([],{})
assert id(a.x) != id(b.x)
assert id(a.x[0]) != id(b.x[0])
assert id(a.x[1]) != id(b.x[1])
from recordclass import Factory
class A(dataobject, copy_default=True):
l: list = []
x: tuple = Factory(lambda: (list(), dict()))
a = A()
b = A()
assert a.x == ([],{})
assert id(a.x) != id(b.x)
assert a.l == []
assert id(a.l) != id(b.l)
* Recordclass supports python 3.12 (tested on linux/debian 11/12 and windows via appveyor).
#### 0.20.1
* Improve row_factory for `sqlite` on the ground of `dataobject`-based classes.
* Move recordclass repository to [github](https://github.com/intellimath/recordclass) from [bitbucket](hhtps://bitbucket.org).
#### 0.20
* Library codebase is compatible with python 3.12
(tested for linux only, windows until python3.12 support on appveyor).
* Fix error with update of readonly attribute via `update` function.
#### 0.19.2
* Exception message for Cls(**kwargs) with invalid kweyword argument is more precise (#37).
* Add parameter `immutable_type` for python >= 3.11. If `immutable_type=True` then a generated class
(not an instance) will be immutable. If class do not contain user defuned `__init__` and `__new__`
then instance creation will be faster (via vectorcall protocol).
#### 0.19.1
* Fix regression with `C.attr=value` (with immutable class by default).
#### 0.19
* Add vectorcall protocal to `litetuple` and `mutabletuple`.
* Add vectorcall protocal to `dataobject`.
* Now dataobject's `op.__hash__` return `id(op)` by default.
The option `hashable=True` make dataobject hashably by value.
* Now `dataobject`-based classes, `litetuple` and `mutabletuple` are support
bytecode specializations since Python 3.11 for instance creation and for getattr/setattr.
* Fix `make` function for cases, when subclass have nontrivial `__init__`.
* Note for `dataobject`-based subclasses with non-trivial `__init__` one may want define also `__reduce__`.
For example:
def __reduce__(self):
from recordclass import dataobject, make
tp, args = dataobject.__reduce__(self)
return make, (tp, args)
#### 0.18.4
* Fix a bug #35 with duplicating the field name during inheritance and mixing it with class level attributes.
* Allow use of ClassVar to define class level field.
#### 0.18.3
* Fix bug with a tuple as default value of the field.
* Fix defaults propagtion to subclasses.
* Fix some issues with pickling in the context of dill.
#### 0.18.2
* Slightly improve performance in the default `__init__` when fields have default values or kwargs.
* Remove experimental pypy support: slow and difficult to predict memory footprint.
* Exclude experimental cython modules.
#### 0.18.1.1
* Repackage 0.18.1 with `use_cython=0`
#### 0.18.1
* Allow to initialize fields in the user defined `__init__` method instead of `__new__` (issue 29).
If `__init__` is defined by user then it's responsible for initialization of all fields.
Note that this feature only work for mutable fields.
Instances of the class with `readonly=True` must be initialized only in the default `__new__`.
For example:
class A(dataobject):
x:int
y:int
def __init__(self, x, y):
self.x = x
self.y = y
* `fast_new=True` by default.
* Add `make_row_factory` for `sqlite3` :
class Planet(dataobject):
name:str
radius:int
>>> con = sql.connect(":memory:")
>>> cur = con.execute("SELECT 'Earth' AS name, 6378 AS radius")
>>> cur.row_factory = make_row_factory(Planet)
>>> row = cur.fetchone()
>>> print(row)
Planet(name='Earth', radius=6378)
#### 0.18.0.1
* Exclude test_dataobject_match.py (for testing `match` statement) for python < 3.10.
#### 0.18
* Python 3.11 support.
* Adapt data object to take benefit from bytecode specialization in 3.11.
* Fix issue for argument with default value in `__new__`, which havn't `__repr__`
that can be interpreted as valid python expression
for creation of the default value.
* Add support for typing.ClassVar.
* Add `Py_TPFLAGS_SEQUENCE` and `Py_TPFLAGS_MAPPING`.
* Add `__match_args__` to support match protocol for dataobject-based subclasses.
#### 0.17.5
* Make to compile, to build and to test successfully for python 3.11.
#### 0.17.4
* Fixed error with missing `_PyObject_GC_Malloc` in 3.11.
#### 0.17.3
* Fix compatibility issue: restore gnu98 C-syntax.
* Fix remained issues with use of "Py_SIZE(op)" and "Py_TYPE(op)" as l-value.
#### 0.17.2
* Add support for python 3.10.
* There are no use of "Py_SIZE(op)" and "Py_TYPE(op)" as l-value.
#### 0.17.1
* Fix packaging issue with cython=1 in setup.py
#### 0.17
* Now recordclass library may be compiled for pypy3, but there is still no complete runtime compatibility with pypy3.
* Slighly imporove performance of `litetuple` / `mutabletuple`.
* Slighly imporove performance of `dataobject`-based subclasses.
* Add adapter `as_dataclass`. For example:
@as_dataclass()
class Point:
x:int
y:int
* Module _litelist is implemented in pure C.
* Make dataobject.__copy__ faster.
#### 0.16.3
* Add possibility for recordclasses to assighn values by key:
A = recordclass("A", "x y", mapping=True)
a = A(1,2)
a['x'] = 100
a['y'] = 200
#### 0.16.2
* Fix the packaging bug in 0.16.1.
#### 0.16.1
* Add `dictclass` factory function to generate class with `dict-like` API and without attribute access to the fields.
Features: fast instance creation, small memory footprint.
#### 0.16
* `RecordClass` started to be a direct subclass of dataobject with `sequence=True` and support
of `namedtuple`-like API.
Insted of `RecordClass(name, fields, **kw)` for class creation
use factory function `recordclass(name, fields, **kw)`
(it allows to specify types).
* Add option api='dict' to `make_dataclass` for creating class that support dict-like API.
* Now one can't remove dataobject's property from it's class using del or builting delattr.
For example:
>>> Point = make_dataclass("Point", "x y")
>>> del Point.x
...........
AttributeError: Attribute x of the class Point can't be deleted
* Now one can't delete field's value using del or builting delattr.
For example:
>>> p = Point(1, 2)
>>> del p.x
...........
AttributeError: The value can't be deleted"
Insted one can use assighnment to None:
>>> p = Point(1, 2)
>>> p.x = None
* Slightly improve performance of the access by index of dataobject-based classes with option `sequence=True`.
#### 0.15.1
* Options `readonly` and `iterable` now can be sspecified via keyword arguments in class statement.
For example:
class Point(dataobject, readonly=True, iterable=True):
x:int
y:int
* Add `update(cls, **kwargs)` function to update attribute values.`
#### 0.15
* Now library supports only Python >= 3.6
* 'gc' and 'fast_new' options now can be specified as kwargs in class statement.
* Add a function `astuple(ob)` for transformation dataobject instance `ob` to a tuple.
* Drop datatuple based classes.
* Add function `make(cls, args, **kwargs)` to create instance of the class `cls`.
* Add function `clone(ob, **kwargs)` to clone dataobject instance `ob`.
* Make structclass as alias of make_dataclass.
* Add option 'deep_dealloc' (@clsconfig(deep_dealloc=True)) for deallocation
instances of dataobject-based recursive subclasses.
#### 0.14.3:
* Subclasses of `dataobject` now support iterable and hashable protocols by default.
#### 0.14.2:
* Fix compilation issue for python 3.9.
#### 0.14.1:
* Fix issue with __hash__ when subclassing recordclass-based classes.
#### 0.14:
* Add __doc__ to generated `dataobject`-based class in order to support `inspect.signature`.
* Add `fast_new` argument/option for fast instance creation.
* Fix refleak in `litelist`.
* Fix sequence protocol ability for `dataobject`/`datatuple`.
* Fix typed interface for `StructClass`.
#### 0.13.2
* Fix issue #14 with deepcopy of dataobjects.
#### 0.13.1
* Restore ``join_classes` and add new function `join_dataclasses`.
#### 0.13.0.1
* Remove redundant debug code.
#### 0.13
* Make `recordclass` compiled and work with cpython 3.8.
* Move repository to **git** instead of mercurial since bitbucket will drop support of mercurial repositories.
* Fix some potential reference leaks.
#### 0.12.0.1
* Fix missing .h files.
#### 0.12
* `clsconfig` now become the main decorator for tuning dataobject-based classes.
* Fix concatenation of mutabletuples (issue `#10`).
#### 0.11.1:
* `dataobject` instances may be deallocated faster now.
#### 0.11:
* Rename `memoryslots` to `mutabletuple`.
* `mutabletuple` and `immutabletuple` dosn't participate in cyclic garbage collection.
* Add `litelist` type for list-like objects, which doesn't participate in cyglic garbage collection.
#### 0.10.3:
* Introduce DataclassStorage and RecordclassStorage.
They allow cache classes and used them without creation of new one.
* Add `iterable` decorator and argument. Now dataobject with fields isn't iterable by default.
* Move `astuple` to `dataobject.c`.
#### 0.10.2
* Fix error with dataobject's `__copy__`.
* Fix error with pickling of recordclasses and structclasses, which was appeared since 0.8.5
(Thanks to Connor Wolf).
#### 0.10.1
* Now by default sequence protocol is not supported by default if dataobject has fields,
but iteration is supported.
* By default argsonly=False for usability reasons.
#### 0.10
* Invent new factory function `make_class` for creation of different kind of dataobject classes
without GC support by default.
* Invent new metaclass `datatype` and new base class `dataobject` for creation dataobject class using
`class` statement.
It have disabled GC support, but could be enabled by decorator `dataobject.enable_gc`.
It support type hints (for python >= 3.6) and default values.
It may not specify sequence of field names in `__fields__` when type hints are applied to all
data attributes (for python >= 3.6).
* Now `recordclass`-based classes may not support cyclic garbage collection too.
This reduces the memory footprint by the size of `PyGC_Head`.
Now by default recordclass-based classes doesn't support cyclic garbage collection.
#### 0.9
* Change version to 0.9 to indicate a step forward.
* Cleanup `dataobject.__cinit__`.
#### 0.8.5
* Make `arrayclass`-based objects support setitem/getitem and `structclass`-based objects able
to not support them. By default, as before `structclass`-based objects support setitem/getitem protocol.
* Now only instances of `dataobject` are comparable to 'arrayclass'-based and `structclass`-based instances.
* Now generated classes can be hashable.
#### 0.8.4
* Improve support for readonly mode for structclass and arrayclass.
* Add tests for arrayclass.
#### 0.8.3
* Add typehints support to structclass-based classes.
#### 0.8.2
* Remove `usedict`, `gc`, `weaklist` from the class `__dict__`.
#### 0.8.1
* Remove Cython dependence by default for building `recordclass` from the sources [Issue #7].
#### 0.8
* Add `structclass` factory function. It's analog of `recordclass` but with less memory
footprint for it's instances (same as for instances of classes with `__slots__`) in the camparison
with `recordclass` and `namedtuple`
(it currently implemented with `Cython`).
* Add `arrayclass` factory function which produce a class for creation fixed size array.
The benefit of such approach is also less memory footprint
(it currently currently implemented with `Cython`).
* `structclass` factory has argument `gc` now. If `gc=False` (by default) support of cyclic garbage collection
will switched off for instances of the created class.
* Add function `join(C1, C2)` in order to join two `structclass`-based classes C1 and C2.
* Add `sequenceproxy` function for creation of immutable and hashable proxy object from class instances,
which implement access by index
(it currently currently implemented with `Cython`).
* Add support for access to recordclass object attributes by idiom: `ob['attrname']` (Issue #5).
* Add argument `readonly` to recordclass factory to produce immutable namedtuple.
In contrast to `collection.namedtuple` it use same descriptors as for
regular recordclasses for performance increasing.
#### 0.7
* Make mutabletuple objects creation faster. As a side effect: when number of fields >= 8
recordclass instance creation time is not biger than creation time of instaces of
dataclasses with `__slots__`.
* Recordclass factory function now create new recordclass classes in the same way as namedtuple in 3.7
(there is no compilation of generated python source of class).
#### 0.6
* Add support for default values in recordclass factory function in correspondence
to same addition to namedtuple in python 3.7.
#### 0.5
* Change version to 0.5
#### 0.4.4
* Add support for default values in RecordClass (patches from Pedro von Hertwig)
* Add tests for RecorClass (adopted from python tests for NamedTuple)
#### 0.4.3
* Add support for typing for python 3.6 (patches from Vladimir Bolshakov).
* Resolve memory leak issue.
#### 0.4.2
* Fix memory leak in property getter/setter
Raw data
{
"_id": null,
"home_page": "https://github.com/intellimath/recordclass",
"name": "recordclass",
"maintainer": null,
"docs_url": null,
"requires_python": null,
"maintainer_email": null,
"keywords": "namedtuple, recordclass, dataclass, dataobject",
"author": "Zaur Shibzukhov",
"author_email": "szport@gmail.com",
"download_url": "https://files.pythonhosted.org/packages/fd/ee/f45fac2500ef2e401b6073023b59ae6a51e189732ca85409b0dfbb3f51a4/recordclass-0.22.1.tar.gz",
"platform": "Linux",
"description": " # Recordclass library\n\n**Recordclass** is [MIT Licensed](http://opensource.org/licenses/MIT) python library.\nIt was started as a \"proof of concept\" for the problem of fast \"mutable\"\nalternative of `namedtuple` (see [question](https://stackoverflow.com/questions/29290359/existence-of-mutable-named-tuple-in-python) on [stackoverflow](https://stackoverflow.com)).\nIt was evolved further in order to provide more memory saving, fast and flexible types.\n\n**Recordclass** library provide record/data-like classes that do not participate in cyclic *garbage collection* (GC) mechanism by default, but support only *reference counting* for garbage collection.\nThe instances of such classes havn't `PyGC_Head` prefix in the memory, which decrease their size and have a little faster path for the instance creation and deallocation.\nThis may make sense in cases where it is necessary to limit the size of the objects as much as possible, provided that they will never be part of references cycles in the application.\nFor example, when an object represents a record with fields with values of simple types by convention (`int`, `float`, `str`, `date`/`time`/`datetime`, `timedelta`, etc.).\n\nIn order to illustrate this, consider a simple class with type hints:\n\n class Point:\n x: int\n y: int\n\nBy tacit agreement instances of the class `Point` is supposed to have attributes `x` and `y` with values of `int` type. Assigning other types of values, which are not subclass of `int`, should be considered as a violation of the agreement.\n\nOther examples are non-recursive data structures in which all leaf elements represent a value of an atomic type.\nOf course, in python, nothing prevent you from \u201cshooting yourself in the foot\" by creating the reference cycle in the script or application code.\nBut in many cases, this can still be avoided provided that the developer understands what he is doing and uses such classes in the codebase with care.\nAnother option is to use static code analyzers along with type annotations to monitor compliance with typehints.\n\nThe library is built on top of the base class `dataobject`. The type of `dataobject` is special metaclass `datatype`.\n It control creation of subclasses, which will not participate in cyclic GC and do not contain `PyGC_Head`-prefix, `__dict__` and `__weakref__` by default.\n As the result the instance of such class need less memory.\n It's memory footprint is similar to memory footprint of instances of the classes with `__slots__` but without `PyGC_Head`. So the difference in memory size is equal to the size of `PyGC_Head`.\n It also tunes `basicsize` of the instances, creates descriptors for the fields and etc.\n All subclasses of `dataobject` created by `class statement` support `attrs`/`dataclasses`-like API.\n For example:\n\n from recordclass import dataobject, astuple, asdict\n class Point(dataobject):\n x:int\n y:int\n\n >>> p = Point(1, 2)\n >>> astuple(p)\n (1, 2)\n >>> asdict(p)\n {'x':1, 'y':2}\n\nThe `recordclass` factory create dataobject-based subclass with specified fields and the support of `namedtuple`-like API.\n By default it will not participate in cyclic GC too.\n\n >>> from recordclass import recordclass\n >>> Point = recordclass('Point', 'x y')\n >>> p = Point(1, 2)\n >>> p.y = -1\n >>> print(p._astuple)\n (1, -1)\n >>> x, y = p\n >>> print(p._asdict)\n {'x':1, 'y':-1}\n\nIt also provide a factory function `make_dataclass` for creation of subclasses of `dataobject` with the specified field names.\n These subclasses support `attrs`/`dataclasses`-like API. It's equivalent to creating subclasses of dataobject using `class statement`.\n For example:\n\n >>> Point = make_dataclass('Point', 'x y')\n >>> p = Point(1, 2)\n >>> p.y = -1\n >>> print(p.x, p.y)\n 1 -1\n\n If one want to use some sequence for initialization then:\n\n >>> p = Point(*sequence)\n\n\nThere is also a factory function `make_arrayclass` for creation of the subclass of `dataobject`, which can be considered as a compact array of simple objects.\n For example:\n\n >>> Pair = make_arrayclass(2)\n >>> p = Pair(2, 3)\n >>> p[1] = -1\n >>> print(p)\n Pair(2, -1)\n\nThe library provide in addition the classes `lightlist` (immutable) and `litetuple`, which considers as list-like and tuple-like *light* containers in order to save memory. They do not supposed to participate in cyclic GC too. Mutable variant of litetuple is called by `mutabletuple`.\n For example:\n\n >>> lt = litetuple(1, 2, 3)\n >>> mt = mutabletuple(1, 2, 3)\n >>> lt == mt\n True\n >>> mt[-1] = -3\n >>> lt == mt\n False\n >>> print(sys.getsizeof((1,2,3)), sys.getsizeof(litetuple(1,2,3)))\n 64 48\n\nNote if one like create `litetuple` or `mutabletuple` from some iterable then:\n\n >>> seq = [1,2,3]\n >>> lt = litetuple(*seq)\n >>> mt = mutabletuple(*seq)\n\n### Memory footprint\n\nThe following table explain memory footprints of the `dataobject`-based objects and litetuples:\n\n<table border=\"1\" class=\"dataframe\">\n <thead>\n <tr style=\"text-align: right;\">\n <th>tuple/namedtuple</th>\n <th>class with __slots__</th>\n <th>recordclass/dataobject</th>\n <th>litetuple/mutabletuple</th>\n </tr>\n </thead>\n <tbody>\n <tr>\n <td>g+b+s+n×p</td>\n <td>g+b+n×p</td>\n <td>b+n×p</td>\n <td>b+s+n×p</td>\n </tr>\n </tbody>\n</table>\n\nwhere:\n\n * b = sizeof(PyObject)\n * s = sizeof(Py_ssize_t)\n * n = number of items\n * p = sizeof(PyObject*)\n * g = sizeof(PyGC_Head)\n\nThis is useful in that case when you absolutely sure that reference cycle isn't supposed.\nFor example, when all field values are instances of atomic types.\nAs a result the size of the instance is decreased by 24-32 bytes for cpython 3.4-3.7 and by 16 bytes for cpython >=3.8.\n\n### Performance counters\n\nHere is the table with performance counters, which was measured using `tools/perfcounts.py` script:\n\n* recordclass 0.21, python 3.10, debian/testing linux, x86-64:\n\n<table border=\"1\" class=\"dataframe\">\n <thead>\n <tr style=\"text-align: right;\">\n <th>id</th>\n <th>size</th>\n <th>new</th>\n <th>getattr</th>\n <th>setattr</th>\n <th>getitem</th>\n <th>setitem</th>\n <th>getkey</th>\n <th>setkey</th>\n <th>iterate</th>\n <th>copy</th>\n </tr>\n </thead>\n <tbody>\n <tr>\n <td>litetuple</td>\n <td>48</td>\n <td>0.18</td>\n <td></td>\n <td></td>\n <td>0.2</td>\n <td></td>\n <td></td>\n <td></td>\n <td>0.33</td>\n <td>0.19</td>\n </tr>\n <tr>\n <td>mutabletuple</td>\n <td>48</td>\n <td>0.18</td>\n <td></td>\n <td></td>\n <td>0.21</td>\n <td>0.21</td>\n <td></td>\n <td></td>\n <td>0.33</td>\n <td>0.18</td>\n </tr>\n <tr>\n <td>tuple</td>\n <td>64</td>\n <td>0.24</td>\n <td></td>\n <td></td>\n <td>0.21</td>\n <td></td>\n <td></td>\n <td></td>\n <td>0.37</td>\n <td>0.16</td>\n </tr>\n <tr>\n <td>namedtuple</td>\n <td>64</td>\n <td>0.75</td>\n <td>0.23</td>\n <td></td>\n <td>0.21</td>\n <td></td>\n <td></td>\n <td></td>\n <td>0.33</td>\n <td>0.21</td>\n </tr>\n <tr>\n <td>class+slots</td>\n <td>56</td>\n <td>0.68</td>\n <td>0.29</td>\n <td>0.33</td>\n <td></td>\n <td></td>\n <td></td>\n <td></td>\n <td></td>\n <td></td>\n </tr>\n <tr>\n <td>dataobject</td>\n <td>40</td>\n <td>0.25</td>\n <td>0.23</td>\n <td>0.29</td>\n <td>0.2</td>\n <td>0.22</td>\n <td></td>\n <td></td>\n <td>0.33</td>\n <td>0.2</td>\n </tr>\n <tr>\n <td>dataobject+gc</td>\n <td>56</td>\n <td>0.27</td>\n <td>0.22</td>\n <td>0.29</td>\n <td>0.19</td>\n <td>0.21</td>\n <td></td>\n <td></td>\n <td>0.35</td>\n <td>0.22</td>\n </tr>\n <tr>\n <td>dict</td>\n <td>232</td>\n <td>0.32</td>\n <td></td>\n <td></td>\n <td></td>\n <td></td>\n <td>0.2</td>\n <td>0.24</td>\n <td>0.35</td>\n <td>0.25</td>\n </tr>\n <tr>\n <td>dataobject+map</td>\n <td>40</td>\n <td>0.25</td>\n <td>0.23</td>\n <td>0.3</td>\n <td></td>\n <td></td>\n <td>0.29</td>\n <td>0.29</td>\n <td>0.32</td>\n <td>0.2</td>\n </tr>\n </tbody>\n</table>\n\n* recordclass 0.21, python 3.11, debian/testing linux, x86-64:\n\n<table>\n <thead>\n <tr>\n <th>id</th>\n <th>size</th>\n <th>new</th>\n <th>getattr</th>\n <th>setattr</th>\n <th>getitem</th>\n <th>setitem</th>\n <th>getkey</th>\n <th>setkey</th>\n <th>iterate</th>\n <th>copy</th>\n </tr>\n </thead>\n <tbody>\n <tr>\n <td>litetuple</td>\n <td>48</td>\n <td>0.11</td>\n <td> </td>\n <td> </td>\n <td>0.11</td>\n <td> </td>\n <td> </td>\n <td> </td>\n <td>0.18</td>\n <td>0.09</td>\n </tr>\n <tr>\n <td>mutabletuple</td>\n <td>48</td>\n <td>0.11</td>\n <td> </td>\n <td> </td>\n <td>0.11</td>\n <td>0.12</td>\n <td> </td>\n <td> </td>\n <td>0.18</td>\n <td>0.08</td>\n </tr>\n <tr>\n <td>tuple</td>\n <td>64</td>\n <td>0.1</td>\n <td> </td>\n <td> </td>\n <td>0.08</td>\n <td> </td>\n <td> </td>\n <td> </td>\n <td>0.17</td>\n <td>0.1</td>\n </tr>\n <tr>\n <td>namedtuple</td>\n <td>64</td>\n <td>0.49</td>\n <td>0.13</td>\n <td> </td>\n <td>0.11</td>\n <td> </td>\n <td> </td>\n <td> </td>\n <td>0.17</td>\n <td>0.13</td>\n </tr>\n <tr>\n <td>class+slots</td>\n <td>56</td>\n <td>0.31</td>\n <td>0.06</td>\n <td>0.06</td>\n <td> </td>\n <td> </td>\n <td> </td>\n <td> </td>\n <td> </td>\n <td> </td>\n </tr>\n <tr>\n <td>dataobject</td>\n <td>40</td>\n <td>0.13</td>\n <td>0.06</td>\n <td>0.06</td>\n <td>0.11</td>\n <td>0.12</td>\n <td> </td>\n <td> </td>\n <td>0.16</td>\n <td>0.12</td>\n </tr>\n <tr>\n <td>dataobject+gc</td>\n <td>56</td>\n <td>0.14</td>\n <td>0.06</td>\n <td>0.06</td>\n <td>0.1</td>\n <td>0.12</td>\n <td> </td>\n <td> </td>\n <td>0.16</td>\n <td>0.14</td>\n </tr>\n <tr>\n <td>dict</td>\n <td>184</td>\n <td>0.2</td>\n <td> </td>\n <td> </td>\n <td> </td>\n <td> </td>\n <td>0.12</td>\n <td>0.13</td>\n <td>0.19</td>\n <td>0.13</td>\n </tr>\n <tr>\n <td>dataobject+map</td>\n <td>40</td>\n <td>0.12</td>\n <td>0.07</td>\n <td>0.06</td>\n <td> </td>\n <td> </td>\n <td>0.15</td>\n <td>0.16</td>\n <td>0.16</td>\n <td>0.12</td>\n </tr>\n <tr>\n <td>class</td>\n <td>56</td>\n <td>0.35</td>\n <td>0.06</td>\n <td>0.06</td>\n <td> </td>\n <td> </td>\n <td> </td>\n <td> </td>\n <td> </td>\n <td> </td>\n </tr>\n </tbody>\n</table>\n\n* recordclas 0.21, python3.12, debian/testing linux, x86-64:\n\n<table>\n <thead>\n <tr>\n <th>id</th>\n <th>size</th>\n <th>new</th>\n <th>getattr</th>\n <th>setattr</th>\n <th>getitem</th>\n <th>setitem</th>\n <th>getkey</th>\n <th>setkey</th>\n <th>iterate</th>\n <th>copy</th>\n </tr>\n </thead>\n <tbody>\n <tr>\n <td>litetuple</td>\n <td>48</td>\n <td>0.13</td>\n <td> </td>\n <td> </td>\n <td>0.12</td>\n <td> </td>\n <td> </td>\n <td> </td>\n <td>0.19</td>\n <td>0.09</td>\n </tr>\n <tr>\n <td>mutabletuple</td>\n <td>48</td>\n <td>0.13</td>\n <td> </td>\n <td> </td>\n <td>0.11</td>\n <td>0.12</td>\n <td> </td>\n <td> </td>\n <td>0.18</td>\n <td>0.09</td>\n </tr>\n <tr>\n <td>tuple</td>\n <td>64</td>\n <td>0.11</td>\n <td> </td>\n <td> </td>\n <td>0.09</td>\n <td> </td>\n <td> </td>\n <td> </td>\n <td>0.16</td>\n <td>0.09</td>\n </tr>\n <tr>\n <td>namedtuple</td>\n <td>64</td>\n <td>0.52</td>\n <td>0.13</td>\n <td> </td>\n <td>0.11</td>\n <td> </td>\n <td> </td>\n <td> </td>\n <td>0.16</td>\n <td>0.12</td>\n </tr>\n <tr>\n <td>class+slots</td>\n <td>56</td>\n <td>0.34</td>\n <td>0.08</td>\n <td>0.07</td>\n <td> </td>\n <td> </td>\n <td> </td>\n <td> </td>\n <td> </td>\n <td> </td>\n </tr>\n <tr>\n <td>dataobject</td>\n <td>40</td>\n <td>0.14</td>\n <td>0.08</td>\n <td>0.08</td>\n <td>0.11</td>\n <td>0.12</td>\n <td> </td>\n <td> </td>\n <td>0.17</td>\n <td>0.12</td>\n </tr>\n <tr>\n <td>dataobject+gc</td>\n <td>56</td>\n <td>0.15</td>\n <td>0.08</td>\n <td>0.07</td>\n <td>0.12</td>\n <td>0.12</td>\n <td> </td>\n <td> </td>\n <td>0.17</td>\n <td>0.13</td>\n </tr>\n <tr>\n <td>dict</td>\n <td>184</td>\n <td>0.19</td>\n <td> </td>\n <td> </td>\n <td> </td>\n <td> </td>\n <td>0.11</td>\n <td>0.14</td>\n <td>0.2</td>\n <td>0.12</td>\n </tr>\n <tr>\n <td>dataobject+map</td>\n <td>40</td>\n <td>0.14</td>\n <td>0.08</td>\n <td>0.08</td>\n <td> </td>\n <td> </td>\n <td>0.16</td>\n <td>0.17</td>\n <td>0.17</td>\n <td>0.12</td>\n </tr>\n <tr>\n <td>class</td>\n <td>48</td>\n <td>0.41</td>\n <td>0.08</td>\n <td>0.08</td>\n <td> </td>\n <td> </td>\n <td> </td>\n <td> </td>\n <td> </td>\n <td> </td>\n </tr>\n </tbody>\n</table>\n\n\nMain repository for `recordclass` is on [github](https://github.com/intellimath/recordclass).\n\nHere is also a simple [example](https://github.com/intellimath/recordclass/blob/main/examples/what_is_recordclass.ipynb).\n\nMore examples can be found in the folder [examples](https://github.com/intellimath/recordclass/tree/main/examples).\n\n## Quick start\n\n### Installation\n\n#### Installation from directory with sources\n\nInstall:\n\n >>> python3 setup.py install\n\nRun tests:\n\n >>> python3 test_all.py\n\n#### Installation from PyPI\n\nInstall:\n\n >>> pip3 install recordclass\n\nRun tests:\n\n >>> python3 -c \"from recordclass.test import *; test_all()\"\n\n### Quick start with dataobject\n\n`Dataobject` is the base class for creation of data classes with fast instance creation and small memory footprint. They provide `dataclass`-like API.\n\nFirst load inventory:\n\n >>> from recordclass import dataobject, asdict, astuple, as_dataclass, as_record\n\nDefine class one of the ways:\n\n class Point(dataobject):\n x: int\n y: int\n\nor\n\n @as_dataclass()\n class Point:\n x: int\n y: int\n\nor\n\n @as_record\n def Point(x:int, y:int): pass\n\nor\n\n >>> Point = make_dataclass(\"Point\", [(\"x\",int), (\"y\",int)])\n\nor\n\n >>> Point = make_dataclass(\"Point\", {\"x\":int, \"y\",int})\n\nAnnotations of the fields are defined as a dict in `__annotations__`:\n\n >>> print(Point.__annotations__)\n {'x': <class 'int'>, 'y': <class 'int'>}\n\nThere is default text representation:\n\n >>> p = Point(1, 2)\n >>> print(p)\n Point(x=1, y=2)\n\nThe instances has a minimum memory footprint that is possible for CPython object, which contain only Python objects:\n\n >>> sys.getsizeof(p) # the output below for python 3.8+ (64bit)\n 40\n >>> p.__sizeof__() == sys.getsizeof(p) # no additional space for cyclic GC support\n True\n\nThe instance is mutable by default:\n\n >>> p_id = id(p)\n >>> p.x, p.y = 10, 20\n >>> id(p) == p_id\n True\n >>> print(p)\n Point(x=10, y=20)\n\nThere are functions `asdict` and `astuple` for converting to `dict` and to `tuple`:\n\n >>> asdict(p)\n {'x':10, 'y':20}\n >>> astuple(p)\n (10, 20)\n\nBy default subclasses of dataobject are mutable. If one want make it immutable then there is the option `readonly=True`:\n\n class Point(dataobject, readonly=True):\n x: int\n y: int\n\n >>> p = Point(1,2)\n >>> p.x = -1\n . . . . . . . . . . . . .\n TypeError: item is readonly\n\nBy default subclasses of dataobject are not iterable by default.\nIf one want make it iterable then there is the option `iterable=True`:\n\n class Point(dataobject, iterable=True):\n x: int\n y: int\n\n >>> p = Point(1,2)\n >>> for x in p: print(x)\n 1\n 2\n\nDefault values are also supported::\n\n class CPoint(dataobject):\n x: int\n y: int\n color: str = 'white'\n\nor\n\n >>> CPoint = make_dataclass(\"CPoint\", [(\"x\",int), (\"y\",int), (\"color\",str)], defaults=(\"white\",))\n\n >>> p = CPoint(1,2)\n >>> print(p)\n Point(x=1, y=2, color='white')\n\nBut\n\n class PointInvalidDefaults(dataobject):\n x:int = 0\n y:int\n\nis not allowed. A fields without default value may not appear after a field with default value.\n\nThere is an option `copy_default` (starting from 0.21) in order to assign a copy of the default value when creating an instance:\n\n class Polygon(dataobject, copy_default=True):\n points: list = []\n\n >>> pg1 = Polygon()\n >>> pg2 = Polygon()\n >>> assert pg1.points == pg2.points\n True\n >>> assert id(pg1.points) != id(pg2.points)\n True\n\nA `Factory` (starting from 0.21) allows you to setup a factory function to calculate the default value:\n\n from recordclass import Factory\n\n class A(dataobject, copy_default=True):\n x: tuple = Factory( lambda: (list(), dict()) )\n\n >>> a = A()\n >>> b = A()\n >>> assert a.x == b.x\n True\n >>> assert id(a.x[0]) != id(b.x[0])\n True\n >>> assert id(a.x[1]) != id(b.x[1])\n True\n\nIf someone wants to define a class attribute, then there is a `ClassVar` trick:\n\n class Point(dataobject):\n x:int\n y:int\n color:ClassVar[int] = 0\n\n >>> print(Point.__fields__)\n ('x', 'y')\n >>> print(Point.color)\n 0\n\nIf the default value for the `ClassVar`-attribute is not specified, \nit will just be excluded from the `__fields___`.\n\nStarting with python 3.10 `__match_args__` is specified by default so that `__match_args__` == `__fields__`.\nUser can define it's own during definition:\n\n class User(dataobject):\n first_name: str\n last_name: str\n age: int\n __match_args__ = 'first_name', 'last_name'\n\nor \n\n from recordclass import MATCH\n class User(dataobject):\n first_name: str\n last_name: str\n _: MATCH\n age: int\n\nor\n\n User = make_dataclass(\"User\", \"first_name last_name * age\")\n\n### Quick start with recordclass\n\nThe `recordclass` factory function is designed to create classes that support `namedtuple`'s API, can be mutable and immutable, provide fast creation of the instances and have a minimum memory footprint.\n\nFirst load inventory:\n\n >>> from recordclass import recordclass\n\nExample with `recordclass`:\n\n >>> Point = recordclass('Point', 'x y')\n >>> p = Point(1,2)\n >>> print(p)\n Point(1, 2)\n >>> print(p.x, p.y)\n 1 2\n >>> p.x, p.y = 1, 2\n >>> print(p)\n Point(1, 2)\n >>> sys.getsizeof(p) # the output below is for 64bit cpython3.8+\n 32\n\nExample with class statement and typehints:\n\n >>> from recordclass import RecordClass\n\n class Point(RecordClass):\n x: int\n y: int\n\n >>> print(Point.__annotations__)\n {'x': <class 'int'>, 'y': <class 'int'>}\n >>> p = Point(1, 2)\n >>> print(p)\n Point(1, 2)\n >>> print(p.x, p.y)\n 1 2\n >>> p.x, p.y = 1, 2\n >>> print(p)\n Point(1, 2)\n\nBy default `recordclass`-based class instances doesn't participate in cyclic GC and therefore they are smaller than `namedtuple`-based ones. If one want to use it in scenarios with reference cycles then one have to use option `gc=True` (`gc=False` by default):\n\n >>> Node = recordclass('Node', 'root children', gc=True)\n\nor\n\n class Node(RecordClass, gc=True):\n root: 'Node'\n chilren: list\n\nThe `recordclass` factory can also specify type of the fields:\n\n >>> Point = recordclass('Point', [('x',int), ('y',int)])\n\nor\n\n >>> Point = recordclass('Point', {'x':int, 'y':int})\n\n### Using dataobject-based classes with mapping protocol\n\n class FastMapingPoint(dataobject, mapping=True):\n x: int\n y: int\n\nor\n\n FastMapingPoint = make_dataclass(\"FastMapingPoint\", [(\"x\", int), (\"y\", int)], mapping=True)\n\n >>> p = FastMappingPoint(1,2)\n >>> print(p['x'], p['y'])\n 1 2\n >>> sys.getsizeof(p) # the output below for python 3.10 (64bit)\n 32\n\n### Using dataobject-based classes for recursive data without reference cycles\n\nThere is the option `deep_dealloc` (default value is `False`) for deallocation of recursive datastructures.\nLet consider simple example:\n\n class LinkedItem(dataobject):\n val: object\n next: 'LinkedItem'\n\n class LinkedList(dataobject, deep_dealloc=True):\n start: LinkedItem = None\n end: LinkedItem = None\n\n def append(self, val):\n link = LinkedItem(val, None)\n if self.start is None:\n self.start = link\n else:\n self.end.next = link\n self.end = link\n\nWithout `deep_dealloc=True` deallocation of the instance of `LinkedList` will be failed if the length of the linked list is too large.\nBut it can be resolved with `__del__` method for clearing the linked list:\n\n def __del__(self):\n curr = self.start\n while curr is not None:\n next = curr.next\n curr.next = None\n curr = next\n\nThere is builtin more fast deallocation method using finalization mechanizm when `deep_dealloc=True`. In such case one don't need `__del__` method for clearing the linked list.\n\n> Note that for classes with `gc=True` this method is disabled: the python's cyclic GC is used in these cases.\n\nFor more details see notebook [example_datatypes](https://github.com/intellimath/recordclass/tree/main/examples/example_datatypes.ipynb).\n\n### Changes:\n\n#### 0.22.1:\n\n* Add `pyproject.toml`.\n* Add `pytest.ini` in order to run `pytest`:\n\n >>> pip3 install -e .\n >>> pytest\n\n#### 0.22.0.3:\n\n* Rename `examples\\test_*.py` files since they are detected by `pytest` as a tests.\n* Fix segfault with `litelist` after `0.22.0.2`.\n \n#### 0.22.0.2\n\n* Make release on github with right tag.\n\n#### 0.22.0.1\n\n* Fix regression with `as_dataclass`.\n\n#### 0.22\n\n* Add a base class `datastruct` for subclasses that should behave more like simple datastructures.\n* Fix bug with `__match_args__` (#6).\n* Start support for python 3.13.\n\n#### 0.21.1\n\n* Allow to specify `__match_args__`. For example,\n\n class User(dataobject):\n first_name: str\n last_name: str\n age: int\n __match_args__ = 'first_name', 'last_name'\n\n or\n\n User = make_dataclass(\"User\", \"first_name last_name * age\")\n \n* Add `@as_record` adapter for `def`-style decalarations of dataclasses\n that are considered as just a struct. For example:\n\n @as_record()\n def Point(x:float, y:float, meta=None): pass\n\n >>> p = Point(1,2)\n >>> print(p)\n Point(x=1, y=2, meta=None)\n\n It's almost equivalent to:\n \n Point = make_dataclass('Point', [('x':float), ('y',float),'meta'], (None,))\n\n* The option `fast_new` will be removed in 0.22. It will be always as `fast_new=True` by creation.\n One can specify own `__new__`, for example:\n\n class Point(dataobject):\n x:int\n y:int\n\n def __new__(cls, x=0, y=0):\n return dataobject.__new__(cls, x, y)\n\n* Fix issues with `_PyUnicodeWriter` for python3.13.\n\n#### 0.21\n\n* Add a new option `copy_default` (default `False`) to allow assigning a copy of the default\n value for the field. For example:\n \n class A(dataobject, copy_default=True):\n l: list = []\n\n a = A()\n b = A()\n assert(a.l == b.l)\n assert(id(a.l) != id(b.l))\n\n* Allow to inherit the options: `copy_default`, `gc`, `iterable`. For example:\n \n class Base(dataobject, copy_default=True):\n pass\n\n class A(Base):\n l: list = []\n\n a = A()\n b = A()\n assert a.l == b.l\n assert id(a.l) != id(b.l)\n\n* Add `Factory` to specify factory function for default values. For example:\n\n from recordclass import Factory\n class A(dataobject):\n x: tuple = Factory(lambda: (list(), dict()))\n\n a = A()\n b = A()\n assert a.x == ([],{})\n assert id(a.x) != id(b.x)\n assert id(a.x[0]) != id(b.x[0])\n assert id(a.x[1]) != id(b.x[1])\n\n from recordclass import Factory\n class A(dataobject, copy_default=True):\n l: list = []\n x: tuple = Factory(lambda: (list(), dict()))\n\n a = A()\n b = A()\n assert a.x == ([],{})\n assert id(a.x) != id(b.x)\n assert a.l == []\n assert id(a.l) != id(b.l)\n\n * Recordclass supports python 3.12 (tested on linux/debian 11/12 and windows via appveyor).\n \n#### 0.20.1\n\n* Improve row_factory for `sqlite` on the ground of `dataobject`-based classes.\n* Move recordclass repository to [github](https://github.com/intellimath/recordclass) from [bitbucket](hhtps://bitbucket.org).\n\n#### 0.20\n\n* Library codebase is compatible with python 3.12\n (tested for linux only, windows until python3.12 support on appveyor).\n* Fix error with update of readonly attribute via `update` function.\n\n#### 0.19.2\n\n* Exception message for Cls(**kwargs) with invalid kweyword argument is more precise (#37).\n* Add parameter `immutable_type` for python >= 3.11. If `immutable_type=True` then a generated class\n (not an instance) will be immutable. If class do not contain user defuned `__init__` and `__new__`\n then instance creation will be faster (via vectorcall protocol).\n\n#### 0.19.1\n\n* Fix regression with `C.attr=value` (with immutable class by default).\n\n#### 0.19\n\n* Add vectorcall protocal to `litetuple` and `mutabletuple`.\n* Add vectorcall protocal to `dataobject`.\n* Now dataobject's `op.__hash__` return `id(op)` by default.\n The option `hashable=True` make dataobject hashably by value.\n* Now `dataobject`-based classes, `litetuple` and `mutabletuple` are support\n bytecode specializations since Python 3.11 for instance creation and for getattr/setattr.\n* Fix `make` function for cases, when subclass have nontrivial `__init__`.\n* Note for `dataobject`-based subclasses with non-trivial `__init__` one may want define also `__reduce__`.\n For example:\n\n def __reduce__(self):\n from recordclass import dataobject, make\n tp, args = dataobject.__reduce__(self)\n return make, (tp, args)\n\n\n#### 0.18.4\n\n* Fix a bug #35 with duplicating the field name during inheritance and mixing it with class level attributes.\n* Allow use of ClassVar to define class level field.\n\n#### 0.18.3\n\n* Fix bug with a tuple as default value of the field.\n* Fix defaults propagtion to subclasses.\n* Fix some issues with pickling in the context of dill.\n\n#### 0.18.2\n\n* Slightly improve performance in the default `__init__` when fields have default values or kwargs.\n* Remove experimental pypy support: slow and difficult to predict memory footprint.\n* Exclude experimental cython modules.\n\n#### 0.18.1.1\n\n* Repackage 0.18.1 with `use_cython=0`\n\n#### 0.18.1\n\n* Allow to initialize fields in the user defined `__init__` method instead of `__new__` (issue 29).\n If `__init__` is defined by user then it's responsible for initialization of all fields.\n Note that this feature only work for mutable fields.\n Instances of the class with `readonly=True` must be initialized only in the default `__new__`.\n For example:\n\n class A(dataobject):\n x:int\n y:int\n\n def __init__(self, x, y):\n self.x = x\n self.y = y\n\n* `fast_new=True` by default.\n* Add `make_row_factory` for `sqlite3` :\n\n class Planet(dataobject):\n name:str\n radius:int\n\n >>> con = sql.connect(\":memory:\")\n >>> cur = con.execute(\"SELECT 'Earth' AS name, 6378 AS radius\")\n >>> cur.row_factory = make_row_factory(Planet)\n >>> row = cur.fetchone()\n >>> print(row)\n Planet(name='Earth', radius=6378)\n\n#### 0.18.0.1\n\n* Exclude test_dataobject_match.py (for testing `match` statement) for python < 3.10.\n\n#### 0.18\n\n* Python 3.11 support.\n* Adapt data object to take benefit from bytecode specialization in 3.11.\n* Fix issue for argument with default value in `__new__`, which havn't `__repr__`\n that can be interpreted as valid python expression\n for creation of the default value.\n* Add support for typing.ClassVar.\n* Add `Py_TPFLAGS_SEQUENCE` and `Py_TPFLAGS_MAPPING`.\n* Add `__match_args__` to support match protocol for dataobject-based subclasses.\n\n#### 0.17.5\n\n* Make to compile, to build and to test successfully for python 3.11.\n\n#### 0.17.4\n\n* Fixed error with missing `_PyObject_GC_Malloc` in 3.11.\n\n#### 0.17.3\n\n* Fix compatibility issue: restore gnu98 C-syntax.\n* Fix remained issues with use of \"Py_SIZE(op)\" and \"Py_TYPE(op)\" as l-value.\n\n#### 0.17.2\n\n* Add support for python 3.10.\n* There are no use of \"Py_SIZE(op)\" and \"Py_TYPE(op)\" as l-value.\n\n#### 0.17.1\n\n* Fix packaging issue with cython=1 in setup.py\n\n#### 0.17\n\n* Now recordclass library may be compiled for pypy3, but there is still no complete runtime compatibility with pypy3.\n* Slighly imporove performance of `litetuple` / `mutabletuple`.\n* Slighly imporove performance of `dataobject`-based subclasses.\n* Add adapter `as_dataclass`. For example:\n\n @as_dataclass()\n class Point:\n x:int\n y:int\n\n* Module _litelist is implemented in pure C.\n* Make dataobject.__copy__ faster.\n\n#### 0.16.3\n\n* Add possibility for recordclasses to assighn values by key:\n\n A = recordclass(\"A\", \"x y\", mapping=True)\n a = A(1,2)\n a['x'] = 100\n a['y'] = 200\n\n#### 0.16.2\n\n* Fix the packaging bug in 0.16.1.\n\n#### 0.16.1\n\n* Add `dictclass` factory function to generate class with `dict-like` API and without attribute access to the fields.\n Features: fast instance creation, small memory footprint.\n\n#### 0.16\n\n* `RecordClass` started to be a direct subclass of dataobject with `sequence=True` and support\n of `namedtuple`-like API.\n Insted of `RecordClass(name, fields, **kw)` for class creation\n use factory function `recordclass(name, fields, **kw)`\n (it allows to specify types).\n* Add option api='dict' to `make_dataclass` for creating class that support dict-like API.\n* Now one can't remove dataobject's property from it's class using del or builting delattr.\n For example:\n\n >>> Point = make_dataclass(\"Point\", \"x y\")\n >>> del Point.x\n ...........\n AttributeError: Attribute x of the class Point can't be deleted\n\n* Now one can't delete field's value using del or builting delattr.\n For example:\n\n >>> p = Point(1, 2)\n >>> del p.x\n ...........\n AttributeError: The value can't be deleted\"\n Insted one can use assighnment to None:\n\n >>> p = Point(1, 2)\n >>> p.x = None\n\n* Slightly improve performance of the access by index of dataobject-based classes with option `sequence=True`.\n\n\n#### 0.15.1\n\n* Options `readonly` and `iterable` now can be sspecified via keyword arguments in class statement.\n For example:\n\n class Point(dataobject, readonly=True, iterable=True):\n x:int\n y:int\n\n* Add `update(cls, **kwargs)` function to update attribute values.`\n\n\n#### 0.15\n\n* Now library supports only Python >= 3.6\n* 'gc' and 'fast_new' options now can be specified as kwargs in class statement.\n* Add a function `astuple(ob)` for transformation dataobject instance `ob` to a tuple.\n* Drop datatuple based classes.\n* Add function `make(cls, args, **kwargs)` to create instance of the class `cls`.\n* Add function `clone(ob, **kwargs)` to clone dataobject instance `ob`.\n* Make structclass as alias of make_dataclass.\n* Add option 'deep_dealloc' (@clsconfig(deep_dealloc=True)) for deallocation\n instances of dataobject-based recursive subclasses.\n\n#### 0.14.3:\n\n* Subclasses of `dataobject` now support iterable and hashable protocols by default.\n\n#### 0.14.2:\n\n* Fix compilation issue for python 3.9.\n\n#### 0.14.1:\n\n* Fix issue with __hash__ when subclassing recordclass-based classes.\n\n#### 0.14:\n\n* Add __doc__ to generated `dataobject`-based class in order to support `inspect.signature`.\n* Add `fast_new` argument/option for fast instance creation.\n* Fix refleak in `litelist`.\n* Fix sequence protocol ability for `dataobject`/`datatuple`.\n* Fix typed interface for `StructClass`.\n\n#### 0.13.2\n\n* Fix issue #14 with deepcopy of dataobjects.\n\n#### 0.13.1\n\n* Restore ``join_classes` and add new function `join_dataclasses`.\n\n#### 0.13.0.1\n\n* Remove redundant debug code.\n\n\n#### 0.13\n\n* Make `recordclass` compiled and work with cpython 3.8.\n* Move repository to **git** instead of mercurial since bitbucket will drop support of mercurial repositories.\n* Fix some potential reference leaks.\n\n\n#### 0.12.0.1\n\n* Fix missing .h files.\n\n#### 0.12\n\n* `clsconfig` now become the main decorator for tuning dataobject-based classes.\n* Fix concatenation of mutabletuples (issue `#10`).\n\n#### 0.11.1:\n\n* `dataobject` instances may be deallocated faster now.\n\n#### 0.11:\n\n* Rename `memoryslots` to `mutabletuple`.\n* `mutabletuple` and `immutabletuple` dosn't participate in cyclic garbage collection.\n* Add `litelist` type for list-like objects, which doesn't participate in cyglic garbage collection.\n\n#### 0.10.3:\n\n* Introduce DataclassStorage and RecordclassStorage.\n They allow cache classes and used them without creation of new one.\n* Add `iterable` decorator and argument. Now dataobject with fields isn't iterable by default.\n* Move `astuple` to `dataobject.c`.\n\n#### 0.10.2\n\n* Fix error with dataobject's `__copy__`.\n* Fix error with pickling of recordclasses and structclasses, which was appeared since 0.8.5\n (Thanks to Connor Wolf).\n\n#### 0.10.1\n\n* Now by default sequence protocol is not supported by default if dataobject has fields,\n but iteration is supported.\n* By default argsonly=False for usability reasons.\n\n#### 0.10\n\n* Invent new factory function `make_class` for creation of different kind of dataobject classes\n without GC support by default.\n* Invent new metaclass `datatype` and new base class `dataobject` for creation dataobject class using\n `class` statement.\n It have disabled GC support, but could be enabled by decorator `dataobject.enable_gc`.\n It support type hints (for python >= 3.6) and default values.\n It may not specify sequence of field names in `__fields__` when type hints are applied to all\n data attributes (for python >= 3.6).\n* Now `recordclass`-based classes may not support cyclic garbage collection too.\n This reduces the memory footprint by the size of `PyGC_Head`.\n Now by default recordclass-based classes doesn't support cyclic garbage collection.\n\n#### 0.9\n\n* Change version to 0.9 to indicate a step forward.\n* Cleanup `dataobject.__cinit__`.\n\n#### 0.8.5\n\n* Make `arrayclass`-based objects support setitem/getitem and `structclass`-based objects able\n to not support them. By default, as before `structclass`-based objects support setitem/getitem protocol.\n* Now only instances of `dataobject` are comparable to 'arrayclass'-based and `structclass`-based instances.\n* Now generated classes can be hashable.\n\n\n#### 0.8.4\n\n* Improve support for readonly mode for structclass and arrayclass.\n* Add tests for arrayclass.\n\n#### 0.8.3\n\n* Add typehints support to structclass-based classes.\n\n\n#### 0.8.2\n\n* Remove `usedict`, `gc`, `weaklist` from the class `__dict__`.\n\n#### 0.8.1\n\n* Remove Cython dependence by default for building `recordclass` from the sources [Issue #7].\n\n#### 0.8\n\n* Add `structclass` factory function. It's analog of `recordclass` but with less memory\n footprint for it's instances (same as for instances of classes with `__slots__`) in the camparison\n with `recordclass` and `namedtuple`\n (it currently implemented with `Cython`).\n* Add `arrayclass` factory function which produce a class for creation fixed size array.\n The benefit of such approach is also less memory footprint\n (it currently currently implemented with `Cython`).\n* `structclass` factory has argument `gc` now. If `gc=False` (by default) support of cyclic garbage collection\n will switched off for instances of the created class.\n* Add function `join(C1, C2)` in order to join two `structclass`-based classes C1 and C2.\n* Add `sequenceproxy` function for creation of immutable and hashable proxy object from class instances,\n which implement access by index\n (it currently currently implemented with `Cython`).\n* Add support for access to recordclass object attributes by idiom: `ob['attrname']` (Issue #5).\n* Add argument `readonly` to recordclass factory to produce immutable namedtuple.\n In contrast to `collection.namedtuple` it use same descriptors as for\n regular recordclasses for performance increasing.\n\n#### 0.7\n\n* Make mutabletuple objects creation faster. As a side effect: when number of fields >= 8\n recordclass instance creation time is not biger than creation time of instaces of\n dataclasses with `__slots__`.\n* Recordclass factory function now create new recordclass classes in the same way as namedtuple in 3.7\n (there is no compilation of generated python source of class).\n\n#### 0.6\n\n* Add support for default values in recordclass factory function in correspondence\n to same addition to namedtuple in python 3.7.\n\n#### 0.5\n\n* Change version to 0.5\n\n#### 0.4.4\n\n* Add support for default values in RecordClass (patches from Pedro von Hertwig)\n* Add tests for RecorClass (adopted from python tests for NamedTuple)\n\n#### 0.4.3\n\n* Add support for typing for python 3.6 (patches from Vladimir Bolshakov).\n* Resolve memory leak issue.\n\n#### 0.4.2\n\n* Fix memory leak in property getter/setter\n",
"bugtrack_url": null,
"license": "MIT",
"summary": "Mutable variant of namedtuple -- recordclass, which support assignments, compact dataclasses and other memory saving variants.",
"version": "0.22.1",
"project_urls": {
"Download": "https://pypi.org/project/recordclass/#files",
"Homepage": "https://github.com/intellimath/recordclass"
},
"split_keywords": [
"namedtuple",
" recordclass",
" dataclass",
" dataobject"
],
"urls": [
{
"comment_text": "",
"digests": {
"blake2b_256": "fdeef45fac2500ef2e401b6073023b59ae6a51e189732ca85409b0dfbb3f51a4",
"md5": "1d99bc016c1679256bef97a35bdd9a4f",
"sha256": "80a4c79270edb8fb55bcb96bec0159a292b485c997e2f33b38fdc9e8d6c0c315"
},
"downloads": -1,
"filename": "recordclass-0.22.1.tar.gz",
"has_sig": false,
"md5_digest": "1d99bc016c1679256bef97a35bdd9a4f",
"packagetype": "sdist",
"python_version": "source",
"requires_python": null,
"size": 1333756,
"upload_time": "2024-08-04T18:14:34",
"upload_time_iso_8601": "2024-08-04T18:14:34.640190Z",
"url": "https://files.pythonhosted.org/packages/fd/ee/f45fac2500ef2e401b6073023b59ae6a51e189732ca85409b0dfbb3f51a4/recordclass-0.22.1.tar.gz",
"yanked": false,
"yanked_reason": null
}
],
"upload_time": "2024-08-04 18:14:34",
"github": true,
"gitlab": false,
"bitbucket": false,
"codeberg": false,
"github_user": "intellimath",
"github_project": "recordclass",
"travis_ci": false,
"coveralls": false,
"github_actions": false,
"appveyor": true,
"lcname": "recordclass"
}
JSON
