def get(self, request, data):
bounds = data > maybe | X.get('in_polygon')
return ((data or {}) > as_kwargs(get_car_position_data)
| where(X['car'] | self.filter)
| group_by(X['location'] | (grouping_precision, X, bounds))
| X.iteritems()
| foreach({
'location': X[1][0]['location'],
'cars': X[1] | foreach(X['car']) | self.get_car_data,
})
| tuple)
def get(self, request, data):
bounds = data > maybe | X.get('in_polygon')
return ((data or {}) > as_kwargs(get_car_position_data)
| where(X['car'] | self.filter)
| group_by(X['location'] | (grouping_precision, X, bounds))
| X.iteritems()
| foreach({
'location': X[1][0]['location'],
'cars': X[1] | foreach(X['car']) | self.get_car_data,
})
| tuple)
def test_pipe_exception():
"How an exception in a pipe should look like"
f = pipe | str | foreach(X.upper()) | foreach(~X.lower() | int) | list
with pytest.raises(ValueError) as excinfo:
f('adfasfa')
assert excinfo.value.message == (
"invalid literal for int() with base 10: 'a'\n"
" in pipe | X.lower | X() | int\n"
" in pipe | str | foreach(X.upper | X()) | foreach(X.lower | X() | int) | list"
)
def test_chained(self):
f = ~X.get("item", "").startswith("Hello")
assert f({"item": "Hello world"})
assert not f({"item": "Goodbye world"})
assert not f({})
def test_chained(self):
f = ~X.get('item', '').startswith('Hello')
assert f({'item': 'Hello world'})
assert not f({'item': 'Goodbye world'})
assert not f({})
def test_in(self):
container = "asdf"
f = ~X._in_(container)
assert f("a")
assert not f("b")
def test_in(self):
container = 'asdf'
f = ~X._in_(container)
assert f('a')
assert not f('b')
def test_chained(self):
f = ~X.get('item', '').startswith('Hello')
assert f({'item': 'Hello world'})
assert not f({'item': 'Goodbye world'})
assert not f({})
def test_in(self):
container = 'asdf'
f = ~X._in_(container)
assert f('a')
assert not f('b')
def create_units():
"Creates CarUnits for existing Cars that don't have them"
cars_with_units = CarUnit.objects.values_list('car_id', flat=True)
taken_unit_ids = set(CarUnit.objects.values_list('unit_id', flat=True))
free_unit_ids = count(1) > where_not(X._in_(taken_unit_ids))
cars_without_units = Car.objects.all() > where_not(X.id._in_(cars_with_units))
for car, unit_id in izip(cars_without_units, free_unit_ids):
unit(unit_id, car)
def get_car_last_position(car):
"""
Returns car's last known position.
First attempts to get it from a CarUnit assigned to `car` and if that fails
(no CarUnit or it doesn't know the position) it falls back to the car's
last_position attribute, which might have been filled out manually.
"""
from metrocar.car_unit_api.models import CarUnit
from_car_unit = CarUnit.objects.get_for(car) > maybe | X.get_last_position()
return from_car_unit or car.last_position
def split_by_events(journey, entry):
"""
Returns whether the last two events in `journey` were ENGINE_OFF and LOCKED
-- where we only care about events: ENGINE_OFF, ENGINE_ON, UNLOCKED, LOCKED
"""
from metrocar.car_unit_api.models import Events
events_of_interest = (
Events.ENGINE_OFF,
Events.ENGINE_ON,
Events.UNLOCKED,
Events.LOCKED,
)
events = journey['events'] > where(X._in_(events_of_interest)) | tuple
return (len(events) >= 2 and
(events[-2], events[-1]) == (Events.ENGINE_OFF, Events.LOCKED))
def __init__(self, *args, **kwargs):
super(SmartAdmin, self).__init__(*args, **kwargs)
if self.list_display == admin.ModelAdmin.list_display:
self.list_display = ('__str__', ) + (self._get_fields(
lambda field: type(field) not in self.list_display_exclude))
self.date_hierarchy = (self.date_hierarchy or self.all_fields > maybe
| select_first(type | X._in_([DateTimeField, DateField]))
| X.name)
self.list_filter = self.list_filter or self._get_list_filter()
self.search_fields = self.search_fields or self._get_search_fields()
self.raw_id_fields = self.raw_id_fields or self._get_fields(
self.should_be_raw_id_field)
self.filter_horizontal = self.filter_horizontal or self._get_fields(
type | (X == ManyToManyField))
def validate(*rules):
"""
Creates a validation function that will check if it's input satisfies
`rules`.
`rules` should be an (arbitrarily nested) sequence of functions
that take one argument and return a tuple of:
``(valid: bool, error: string or None)``
where `valid` says if the argument satisfies the rule and `error` says
why not if it doesn't.
The rules are checked sequentially and when an error is encountered, it is
returned immediately from the function, without checking the rest of the
rules. The returned value is the one returned from the rule, i.e.
``(False, "error message")``
If no error is encountered the function returns ``(True, None)``.
(Note that the validation function itself is a rule.)
"""
rules = rules > flatten | tuple
return lambda val: rules > foreach(X(val)) | select_first(X != OK) or OK
def ready_to_finish(self):
"""
Returns true if reservation is ready to be finished
"""
from metrocar.cars.models import Parking
if self.finished or self.ended is not None: return True
if self.started is None: return False
if not self.car.dedicated_parking_only:
# cars which doesn't have dedicated parking are little trouble
# as we can't rightfully decide if their reservation can be
# finished
# => they are collected by reservation deamon
return False
elif settings.GEO_ENABLED:
# is there a Parking that contains car's last_position?
return (self.car > maybe
| get_car_last_position
| X['location']
| 'POINT ({0} {1})'
| xcurry(Parking.objects.filter, polygon__contains=X)
| X.exists())
def test_call(self):
f = ~X(42)
assert f(lambda n: n / 2) == 21
"""
The public API
"""
from datetime import datetime
from pipetools import pipe, X
from geotrack.backends import get_backend
from geotrack.queries import get_query
from geotrack.utils import extract_timestamp
def store(unit_id, timestamp, location, **kwargs):
if isinstance(timestamp, basestring):
timestamp = extract_timestamp(timestamp)
backend = get_backend()
backend.store(
unit_id=unit_id,
timestamp=timestamp,
location=location,
added=datetime.now(),
**kwargs)
def query(query_name, **kwargs):
backend = get_backend()
query = get_query(query_name, backend=backend)
return query(**kwargs)
flush = pipe | get_backend | X.flush()
def test_name(self):
f = ~X.attr(1, 2, three='four')
assert f.__name__ == "X.attr | X(1, 2, three='four')"
def test_basic(self):
f = ~X.startswith('Hello')
assert f('Hello world')
assert not f('Goodbye world')
TestCommand.finalize_options(self)
self.test_args = []
self.test_suite = True
def run_tests(self):
# import here, cause outside the eggs aren't loaded
import pytest
error_code = pytest.main(self.test_args)
sys.exit(error_code)
setup(name='pipetools',
version=pipetools.__versionstr__,
description=('A library that enables function composition similar to '
'using Unix pipes.'),
long_description='README.rst' > open | X.read(),
author='Petr Pokorny',
author_email='*****@*****.**',
license='MIT',
url='http://0101.github.com/pipetools/',
packages=['pipetools'],
include_package_data=True,
install_requires=('setuptools>=0.6b1', ),
tests_require=('pytest', ),
cmdclass={'test': PyTest},
classifiers=[
'Development Status :: 2 - Pre-Alpha',
'Intended Audience :: Developers',
'License :: OSI Approved :: MIT License',
'Operating System :: OS Independent',
'Programming Language :: Python :: 2',
def execute(backend, query, max_items=50, **kwargs):
return (query(**kwargs)
> group_by(X['unit_id'])
| X.iteritems()
| foreach([KEY, VALUE | prune_to(max_items)])
| dict)
def test_basic(self):
f = ~X.startswith('Hello')
assert f('Hello world')
assert not f('Goodbye world')
def execute(backend, query, max_items=50, **kwargs):
return (query(**kwargs) > group_by(X['unit_id'])
| X.iteritems()
| foreach([KEY, VALUE | prune_to(max_items)])
| dict)
def test_with_exception(self):
f = unless(AttributeError, foreach(X.lower()) | list)
assert f(['A', 'B', 37]) is None
def test_name(self):
f = ~X.attr(1, 2, three="four")
assert f.__name__ == "X.attr | X(1, 2, three='four')"
def test_with_exception_in_foreach(self):
f = foreach(unless(AttributeError, X.lower())) | list
assert f(['A', 'B', 37]) == ['a', 'b', None]
self.test_args = []
self.test_suite = True
def run_tests(self):
# import here, cause outside the eggs aren't loaded
import pytest
error_code = pytest.main(self.test_args)
sys.exit(error_code)
setup(
name='pipetools',
version=pipetools.__versionstr__,
description=('A library that enables function composition similar to '
'using Unix pipes.'),
long_description='README.rst' > xpartial(io.open, X, encoding="utf-8") | X.read(),
author='Petr Pokorny',
author_email='*****@*****.**',
license='MIT',
url='http://0101.github.com/pipetools/',
packages=['pipetools'],
include_package_data=True,
install_requires=(
'setuptools>=0.6b1',
),
tests_require=(
'pytest',
),
cmdclass={'test': PyTest},
classifiers=[
self.test_args = []
self.test_suite = True
def run_tests(self):
# import here, cause outside the eggs aren't loaded
import pytest
error_code = pytest.main(self.test_args)
sys.exit(error_code)
setup(
name='pipetools',
version=pipetools.__versionstr__,
description=('A library that enables function composition similar to '
'using Unix pipes.'),
long_description='README.rst' > open | X.read(),
author='Petr Pokorny',
author_email='*****@*****.**',
license='MIT',
url='http://0101.github.com/pipetools/',
packages=['pipetools'],
include_package_data=True,
install_requires=(
'setuptools>=0.6b1',
),
tests_require=(
'pytest',
),
cmdclass={'test': PyTest},
classifiers=[
commit_readme = """
git add README.rst
git commit -m "(readme update)"
"""
update_gh_pages = """
git checkout gh-pages
git merge master
git rm -rf doc
sphinx-build -b html docs/source/ doc
git add doc
git commit -m "doc update"
git checkout master
"""
runscript = X.split('\n') | where(X) | unless(BuildFailure, foreach_do(sh))
if __name__ == '__main__':
create_readme()
runscript(commit_readme)
runscript(update_gh_pages)
def test_repr(self):
f = ~X.attr(1, 2, three='four')
assert repr(f) == "X.attr | X(1, 2, three='four')"
def test_basic(self):
f = ~X.startswith("Hello")
assert f("Hello world")
assert not f("Goodbye world")
self.test_args = []
self.test_suite = True
def run_tests(self):
# import here, cause outside the eggs aren't loaded
import pytest
error_code = pytest.main(self.test_args)
sys.exit(error_code)
setup(name='pipetools',
version=pipetools.__versionstr__,
description=('A library that enables function composition similar to '
'using Unix pipes.'),
long_description='README.rst' >
xpartial(io.open, X, encoding="utf-8") | X.read(),
author='Petr Pokorny',
author_email='*****@*****.**',
license='MIT',
url='https://0101.github.io/pipetools/',
packages=['pipetools'],
include_package_data=True,
install_requires=('setuptools>=0.6b1', ),
tests_require=('pytest', ),
cmdclass={'test': PyTest},
classifiers=[
'Development Status :: 5 - Production/Stable',
'Intended Audience :: Developers',
'License :: OSI Approved :: MIT License',
'Operating System :: OS Independent',
'Programming Language :: Python :: 2',
def test_ok(self):
f = unless(AttributeError, foreach(X.lower())) | list
assert f("ABC") == ['a', 'b', 'c']
"""
The public API
"""
from datetime import datetime
from pipetools import pipe, X
from geotrack.backends import get_backend
from geotrack.queries import get_query
from geotrack.utils import extract_timestamp
def store(unit_id, timestamp, location, **kwargs):
if isinstance(timestamp, basestring):
timestamp = extract_timestamp(timestamp)
backend = get_backend()
backend.store(unit_id=unit_id,
timestamp=timestamp,
location=location,
added=datetime.now(),
**kwargs)
def query(query_name, **kwargs):
backend = get_backend()
query = get_query(query_name, backend=backend)
return query(**kwargs)
flush = pipe | get_backend | X.flush()
def test_with_exception(self):
f = unless(AttributeError, foreach(X.lower()) | list)
assert f(['A', 'B', 37]) is None
def test_repr(self):
f = ~X.attr(1, 2, three='four')
assert repr(f) == "X.attr | X(1, 2, three='four')"
def test_with_exception_in_foreach(self):
f = foreach(unless(AttributeError, X.lower())) | list
assert f(['A', 'B', 37]) == ['a', 'b', None]
def test_ok(self):
f = unless(AttributeError, foreach(X.lower())) | list
assert f("ABC") == ['a', 'b', 'c']
commit_readme = """
git add README.rst
git commit -m "(readme update)"
"""
update_gh_pages = """
git checkout gh-pages
git merge master
git rm -rf doc
sphinx-build -b html docs/source/ doc
git add doc
git commit -m "doc update"
git checkout master
"""
runscript = X.split('\n') | where(X) | unless(BuildFailure, foreach_do(sh))
if __name__ == '__main__':
create_readme()
runscript(commit_readme)
runscript(update_gh_pages)
