`knife.active.sliceknife` — Actively evaluated slicing knife¶

class knife.active.sliceknife(*things, **kw)¶

Actively evaluated slicing knife. Provides slicing operations for incoming things.

>>> from knife.active import sliceknife

__init__(*things, snapshots=5)¶

Parameters:	things – incoming things snapshots (integer) – snapshots to keep (default: `5`)

__len__()¶: Number of incoming things.

__iter__()¶: Iterate over outgoing things.

append(*things)¶

Insert things after other incoming things.

Parameters:	things – incoming things
Return type:	`knife` object

>>> from knife import __
>>> __(3, 4, 5).append(1, 2, 3, 4, 5, 6).peek()
[3, 4, 5, 1, 2, 3, 4, 5, 6]

apply(worker, *args, **kw)¶

Assign callable used to work on incoming things plus any positional arguments and keyword arguments it will use.

Note

Global positional arguments and keyword arguments assigned with params are reset whenever apply is called.

Parameters:	worker – a `callable`
Return type:	`knife` object

ascii(errors='strict')¶

encode outgoing things as bytes with the 'latin-1' codec.

Parameters:	errors (str) – error handling for encoding
Return type:	`knife` object

>>> from stuf.six import u, b
>>> test = __([1], True, r't', b('i'), u('g'), None, (1,))
>>> test.ascii().oneach().peek()
['[1]', 'True', 't', 'i', 'g', 'None', '(1,)']

at(n, default=None)¶

Slice off incoming thing found at index n.

Parameters:	n (int) – index of some incoming thing default – default returned if nothing is found at n
Return type:	`knife` object

>>> from knife import __
>>> # default behavior
>>> __(5, 4, 3, 2, 1).at(2).get()
3
>>> # return default value if nothing found at index
>>> __(5, 4, 3, 2, 1).at(10, 11).get()
11

See also

“nth”: Itertools Recipes

back()¶

Switch back to knife object that piped its incoming things through this knife object.

Return type:	`knife` object

baseline()¶

Restore incoming things back to the baseline snapshot.

Return type:	`knife` object

>>> from knife import __
>>> undone = __(1, 2, 3).prepend(1, 2, 3, 4, 5, 6)
>>> undone.peek()
[1, 2, 3, 4, 5, 6, 1, 2, 3]
>>> undone.snapshot().append(1).append(2).peek()
[1, 2, 3, 4, 5, 6, 1, 2, 3, 1, 2]
>>> undone.baseline().peek()
[1, 2, 3, 4, 5, 6, 1, 2, 3]

bytes(encoding='utf_8', errors='strict')¶

encode outgoing things as bytes.

Parameters:	encoding (str) – character encoding errors (str) – error handling for encoding
Return type:	`knife` object

>>> test = __([1], True, r't', b('i'), u('g'), None, (1,))
>>> test.bytes().oneach().peek()
['[1]', 'True', 't', 'i', 'g', 'None', '(1,)']

choice()¶

Randomly slice off one incoming thing.

Return type:	`knife` object

>>> __(1, 2, 3, 4, 5, 6).choice().get() 
3

See also

random.choice: function in Python standard library

clear()¶

Clear everything.

Return type:	`knife` object

dice(n, fill=None)¶

Slice one iterable incoming thing into n iterable incoming things.

Parameters:	n (int) – number of incoming things per slice fill – value to pad out incomplete iterables
Return type:	`knife` object

>>> __('moe', 'larry', 'curly', 30, 40, 50, True).dice(2, 'x').get()
[('moe', 'larry'), ('curly', 30), (40, 50), (True, 'x')]

See also

“grouper”: Itertools Recipes

first(n=0)¶

Slice off n things from the starting end of incoming things or just the first incoming thing.

Parameters:	n (int) – number of incoming things
Return type:	`knife` object

>>> # default behavior
>>> __(5, 4, 3, 2, 1).first().get()
5
>>> # first things from index 0 to 2
>>> __(5, 4, 3, 2, 1).first(2).get()
[5, 4]

See also

first: function in Underscore.js
first: function in Underscore.lua
first: function in Underscore.perl
first: function in Underscore.php

get()¶: Return outgoing things wrapped with wrap.

Note

With only one outgoing thing, only that one outgoing thing is returned. With multiple outgoing things, they are returned wrapped with the wrapper assigned with wrap (default wrapper is list).

initial()¶

Slice off every incoming thing except the last incoming thing.

Return type:	`knife` object

>>> __(5, 4, 3, 2, 1).initial().get()
[5, 4, 3, 2]

See also

initial: function in Underscore.js
initial: function in Underscore.lua
initial: function in Underscore.perl
initial: function in Underscore.php

last(n=0)¶

Slice off n things from the tail end of incoming things or just the last incoming thing.

Parameters:	n (int) – number of incoming things
Return type:	`knife` object

>>> # default behavior
>>> __(5, 4, 3, 2, 1).last().get()
1
>>> # fetch last two things
>>> __(5, 4, 3, 2, 1).last(2).get()
[2, 1]

See also

last: function in Underscore.js
last: function in Underscore.lua
last: function in Underscore.perl
last: function in Underscore.php

oneach()¶

Toggle whether each outgoing thing should be individually wrapped with the wrapper assigned with wrap (default wrapper is list ) or whether all outgoing things should be wrapped all at once.

Note

knife object default behavior is to wrap all outgoing things all at once. knife objects reset back to this behavior after get or peek is called.

Return type:	`knife` object

original()¶

Restore incoming things back to the original snapshot.

Note

THe original snapshot of incoming things is taken following the first knife method call but before the second knife method call (if there is a second method call)

Return type:	`knife` object

>>> undone = __(1, 2, 3).prepend(1, 2, 3, 4, 5, 6)
>>> undone.peek()
[1, 2, 3, 4, 5, 6, 1, 2, 3]
>>> undone.original().peek()
[1, 2, 3]

params(*args, **kw)¶

Assign positional arguments and keyword arguments to be used globally.

Return type:	`knife` object

pattern(pattern, type='parse', flags=0)¶

Compile search pattern for use as worker.

Note

Global positional arguments and keyword arguments assigned with params are reset whenever a new pattern is compiled.

Parameters:	pattern (str) – search pattern type (str) – engine to compile pattern with. Valid options are ‘parse’, ‘re’, or ‘glob’ flags (int) – regular expression flags
Return type:	`knife` object

>>> # using parse expression
>>> test = __('first test', 'second test', 'third test')
>>> test.pattern('first {}').filter().get()
'first test'
>>> # using glob pattern
>>> test.original().pattern('second*', type='glob').filter().get()
'second test'
>>> # using regular expression
>>> test.original().pattern('third .', type='regex').filter().get()
'third test'

peek()¶: Preview current incoming things wrapped with wrap.

Note

With only one outgoing thing, only that one thing is returned. With multiple outgoing things, everything is returned wrapped with the wrapper assigned with wrap (default wrapper is list).

pipe(knife)¶

Pipe incoming things from some other knife object through this knife object.

Parameters:	knife – another `knife` object
Return type:	`knife` object

prepend(*things)¶

Insert things before other incoming things.

Parameters:	things – incoming things
Return type:	`knife` object

>>> __(3, 4, 5).prepend(1, 2, 3, 4, 5, 6).peek()
[1, 2, 3, 4, 5, 6, 3, 4, 5]

rest()¶

Slice off every incoming thing except the first incoming thing.

Return type:	`knife` object

>>> __(5, 4, 3, 2, 1).rest().get()
[4, 3, 2, 1]

See also

rest: function in Underscore.js
rest: function in Underscore.lua
rest: function in Underscore.perl
rest: function in Underscore.php

sample(n)¶

Randomly slice off n incoming things.

Parameters:	n (int) – sample size
Return type:	`knife` object

>>> __(1, 2, 3, 4, 5, 6).sample(3).get() 
[2, 4, 5]

See also

random.sample: function in Python standard library

slice(start, stop=False, step=False)¶

Take slice out of incoming things.

Parameters:	start (int) – starting index of slice stop (int) – stopping index of slice step (int) – size of step in slice
Return type:	`knife` object

>>> # slice from index 0 to 3
>>> __(5, 4, 3, 2, 1).slice(2).get()
[5, 4]
>>> # slice from index 2 to 4
>>> __(5, 4, 3, 2, 1).slice(2, 4).get()
[3, 2]
>>> # slice from index 2 to 4 with 2 steps
>>> __(5, 4, 3, 2, 1).slice(2, 4, 2).get()
3

See also

itertools.islice: function in Python standard library
slice: function in Underscore.lua

snapshot()¶

Take a baseline snapshot of current incoming things.

Return type:	`knife` object

undo(snapshot=0)¶

Revert incoming things to a previous snapshot.

Note

A snapshot of current incoming things is taken when a knife method is called but before the main body of the method executes.

Parameters:	snapshot (int) – number of steps ago `1`, `2`, `3`, etc.
Return type:	`knife` object

>>> undone = __(1, 2, 3).prepend(1, 2, 3, 4, 5, 6)
>>> undone.peek()
[1, 2, 3, 4, 5, 6, 1, 2, 3]
>>> # undo back one step
>>> undone.append(1).undo().peek()
[1, 2, 3, 4, 5, 6, 1, 2, 3]
>>> # undo back one step
>>> undone.append(1).append(2).undo().peek()
[1, 2, 3, 4, 5, 6, 1, 2, 3, 1]
>>> # undo back 2 steps
>>> undone.append(1).append(2).undo(2).peek()
[1, 2, 3, 4, 5, 6, 1, 2, 3, 1]

unicode(encoding='utf_8', errors='strict')¶

unicode (str under Python 3) decode outgoing things.

Parameters:	encoding (str) – Unicode encoding errors (str) – error handling for decoding
Return type:	`knife` object

>>> test = __([1], True, r't', b('i'), u('g'), None, (1,))
>>> test.unicode().oneach().peek()
[u'[1]', u'True', u't', u'i', u'g', u'None', u'(1,)']

worker(worker)¶

Assign callable used to work on incoming things.

Note

Global positional arguments and keyword arguments assigned with params are reset whenever a new worker is assigned.

Parameters:	worker – a `callable`
Return type:	`knife` object

wrap(wrapper)¶

Assign object, type, or class used to wrap outgoing things.

Note

A knife object resets back to its default wrapper (list) after get or peek is called.

Parameters:	wrapper – an object, `type`, or `class`
Return type:	`knife` object

>>> __(1, 2, 3, 4, 5, 6).wrap(tuple).peek()
(1, 2, 3, 4, 5, 6)

knife documentation