| docs | |
|---|---|
| tests |        
|
| package |      |
Container class boilerplate killer.
Features:
- Human-readable
__repr__ - Complete set of comparison methods
- Keyword and positional argument support. Works like a normal class - you can override just about anything in the
subclass (eg: a custom
__init__). In contrast, hynek/characteristic forces different call schematics and calls your__init__with different arguments.
pip install fields
A class that has 2 attributes, a and b:
>>> from fields import Fields
>>> class Pizza(Fields.name.size):
... pass
...
>>> p = Pizza("Pepperoni", "large")
>>> p
Pizza(name='Pepperoni', size='large')
>>> p.size
'large'
>>> p.name
'Pepperoni'You can also use keyword arguments:
>>> Pizza(size="large", name="Pepperoni")
Pizza(name='Pepperoni', size='large')You can have as many attributes as you want:
>>> class Pizza(Fields.name.ingredients.crust.size):
... pass
...
>>> Pizza("Funghi", ["mushrooms", "mozarella"], "thin", "large")
Pizza(name='Funghi', ingredients=['mushrooms', 'mozarella'], crust='thin', size='large')A class that has one required attribute value and two attributes (left and right) with default value
None:
>>> class Node(Fields.value.left[None].right[None]):
... pass
...
>>> Node(1, Node(2), Node(3, Node(4)))
Node(value=1, left=Node(value=2, left=None, right=None), right=Node(value=3, left=Node(value=4, left=None, right=None), right=None))
>>> Node(1, right=Node(2))
Node(value=1, left=None, right=Node(value=2, left=None, right=None))You can also use it inline:
>>> Fields.name.size("Pepperoni", "large")
FieldsBase(name='Pepperoni', size='large')An alternative to namedtuple:
>>> from fields import Tuple
>>> class Pair(Tuple.a.b):
... pass
...
>>> issubclass(Pair, tuple)
True
>>> p = Pair(1, 2)
>>> p.a
1
>>> p.b
2
>>> tuple(p)
(1, 2)
>>> a, b = p
>>> a
1
>>> b
2Tuples are fast!
benchmark: 9 tests, min 5 rounds (of min 25.00us), 1.00s max time, timer: time.perf_counter Name (time in us) Min Max Mean StdDev Rounds Iterations -------------------------------------------------------------------------------------- test_characteristic 6.0100 1218.4800 11.7102 34.3158 15899 10 test_fields 6.8000 1850.5250 9.8448 33.8487 5535 4 test_slots_fields 6.3500 721.0300 8.6120 14.8090 15198 10 test_super_dumb 7.0111 1289.6667 11.6881 31.6012 15244 9 test_dumb 3.7556 673.8444 5.8010 15.0514 14246 18 test_tuple 3.1750 478.7750 5.1974 9.1878 14642 12 test_namedtuple 3.2778 538.1111 5.0403 9.9177 14105 9 test_attrs_decorated_class 4.2062 540.5125 5.3618 11.6708 14266 16 test_attrs_class 3.7889 316.1056 4.7731 6.0656 14026 18 --------------------------------------------------------------------------------------
https://python-fields.readthedocs.org/
To run all the tests run tox in your shell (pip install tox if you don't have it):
tox
It's less to type, why have quotes around when the names need to be valid symbols anyway. In fact, this is one of the shortest forms possible to specify a container with fields.
But you're abusing a very well known syntax. You're using attribute access instead of a list of strings. Why?
Symbols should be symbols. Why validate strings so they are valid symbols when you can avoid that? Just use symbols. Save on both typing and validation code.
The use of language constructs is not that surprising or confusing in the sense that semantics precede conventional
syntax use. For example, if we have class Person(Fields.first_name.last_name.height.weight): pass then it's going to
be clear we're talking about a Person object with first_name, last_name, height and width fields: the words
have clear meaning.
Again, you should not name your variables as f1, f2 or any other non-semantic symbols anyway.
Semantics precede syntax: it's like looking at a cake resembling a dog, you won't expect the cake to bark and run around.
Yes. Mercilessly tested on Travis and AppVeyor.
Yes, ofcourse.
It's ugly, repetivive and unflexible. Compare this:
>>> from collections import namedtuple
>>> class MyContainer(namedtuple("MyContainer", ["field1", "field2"])):
... pass
>>> MyContainer(1, 2)
MyContainer(field1=1, field2=2)To this:
>>> class MyContainer(Tuple.field1.field2):
... pass
>>> MyContainer(1, 2)
MyContainer(field1=1, field2=2)Ugly, inconsistent - you don't own the class:
Lets try this:
>>> import characteristic >>> @characteristic.attributes(["field1", "field2"]) ... class MyContainer(object): ... def __init__(self, a, b): ... if a > b: ... raise ValueError("Expected %s < %s" % (a, b)) >>> MyContainer(1, 2) Traceback (most recent call last): ... ValueError: Missing keyword value for 'field1'.WHAT !? Ok, lets write some more code:
>>> MyContainer(field1=1, field2=2) Traceback (most recent call last): ... TypeError: __init__() ... arguments...This is bananas. You have to write your class around these quirks.
Lets try this:
>>> class MyContainer(Fields.field1.field2):
... def __init__(self, a, b):
... if a > b:
... raise ValueError("Expected %s < %s" % (a, b))
... super(MyContainer, self).__init__(a, b)Just like a normal class, works as expected:
>>> MyContainer(1, 2)
MyContainer(field1=1, field2=2)Now this is a very difficult question.
Consider this typical use-case:
.. sourcecode:: pycon
>>> import attr >>> @attr.s ... class Point(object): ... x = attr.ib() ... y = attr.ib()
Worth noting:
- attrs is faster because it doesn't allow your class to be
used as a mixin (it doesn't do any
super(cls, self).__init__(...)for you). - the typical use-case doesn't allow you to have a custom
__init__. If you define a custom__init__, it will get overridden by the one attrs generates. - It works better with IDEs and source code analysis tools because of the attributes defined on the class.
All in all, attrs is a fast and minimal container library with no support for subclasses. Definitely worth considering.
Normaly it would, but there's a plugin that makes pylint understand it, just like any other class: pylint-fields.