PK!a CHANGELOG* Version 0.3.0 + Data :: <2019-03-10 Sun> + Add :: - Custom ignore when flatten iterable. * Version 0.2.0 + Data :: <2019-02-15 Fri> + Add :: - flatten in extra. * Version 0.1.0 + Data :: <2019-02-06 Wed> + Commemorate Version :: First Release. PK!LBOO README.html Nalude

Nalude

1 Prologue

I like Haskell, also hope some of the prelude functions in Haskell can be used in Python.

Wish you enjoy coding with nalude.

2 Nalude

Nalude is a standard module, which is inspired by Haskell's Prelude. Thus, nalude is also a library of functional programming.

Nalude doesn't explicitly distinguish between Applicative's or monadic function since they are not well differentiated in the basic structure of Python. Of course, the main reason is that I am too fresh.

The following functions, Nalude tries to implement:

  1. Folds and Traversals
  2. Lists
  3. Miscellaneous
  4. Specials
  5. Strings
  6. Tuples
  7. Zip and Unzip

At the same time, it also implements some functions which are only available in Python and are included in `extra`.

3 Structure of Functions

3.1 Folds and Traversals

foldr(f: Callable[[b, a], b], init: b, t: Sequence[a])
Right-associative fold of a sequence.
foldl(f, init, t)
Left-associative fold of an iterable. The same as reduce.
foldr1(f, t)
A variant of foldr without base case.
foldl1(f, t)
A variant of foldl without base case.
product(nums)
Computes the product of the numbers.
(HELP WANTED) traverse
Map each element of a structure to an action, evaluate these actions from left to right, and collect the results.
(HELP WANTED) sequence
Evaluate each actions in the structure from left to right, and collect the results.

3.2 Lists

head(xs)
Extract the first element of an iterable.
last(xs)
Extract the last element of an iterable.
null(xs)
Test whether the sequence is empty.
(no term)
Infinite lists
iterate(f, x)
Yield a tuple of repeated applications of f to x.
repeat(x)
Repeat x.
replicate(n, x)
Return a list of length n with x the value of every element.
cycle(xs)
Tie an iterable to infinite circuler one.
(no term)
Sublists
tail(xs)
Extract the elements after the head of a list.
init(xs)
Extract all the elements of an iterable except the last one.
take(n, xs)
Return the first n elements of sequence xs.
drop(n, xs)
Return the remaining elements of xs after the first n elements.
splitat(n, xs)
Return a tuple where the first element is xs prefix of length n and second element is the remainder of the sequence xs.
takewhile(p, xs)
Return the longest prefix of xs of elements that satisfy predicate p.
dropwhile(p, xs)
Return the suffix remaining after takewhile(p, xs).
(LAZY ONE HELP WANTED) span(p, xs)
Equal to (takewhile(p, xs), dropwhile(p, xs)).
(LAZY ONE HELP WANTED) break_(p, xs)
Equal to (takewhile(not_(p), xs), dropwhile(not_(p), xs)).

3.3 Miscellaneous

id_(x)
Identity function.
const(x, _)
Evaluates to x for all inputs.
o(f1, f2)
(.) Function composition
flip(f)
Flip takes its two arguments into the reverse order of f.
until(p, f, x)
Yield the result of applying f until p holds.

3.4 String

lines(s)
Break up a string into a list of strings at newline characters.
unlines(xs)
The inverse operation of lines, append a newline to each.
words(s)
Break a string up into a list of words, which were delimited by white space.
unwords(xs)
The inverse operation of words, join words with space.

3.5 Specials

not_(f)
Boolean "not".
all_(p, xs)
Determine whether all elements of the structure satisfy the p.
any_(p, xs)
Determine whether sny elements of the structure satisfies the p.
concat(xss)
The concatenation of all the elements of a container of Sequences.
concatmap(f, xss)
Map a function over all the elements of a container and concatenate the resulting lists.

3.6 Tuples

fst(t)
Extract the first component of a tuple.
snd(t)
Extract the second component of a tuple.
curry(f, a, b)
Converts an uncurried function to a curried function.
uncurry(f, ab@(a, b))
Converts a curried function to a function on pairs.

3.7 Zip and Unzip

zipwith(f, *seqs)
Zipwith is map(f, zip), but f accept separate args instead of tuple
unzip(pairs)
Transform an iterable of pairs into a tuple of sequence. (Not lazy)

3.8 Extra

flatten(xs,*,ignore=(dict,))
Flatten iterables of iterable to a single iterable. It will ignore instances in ignore tuple.

4 Get Start

4.1 Install

pip install nalude

5 Epoligue

5.1 History

5.1.1 Version 0.3.0

Data
<Sun Mar 10, 2019>
Add
  • Custom ignore when flatten iterable.

5.1.2 Version 0.2.0

Data
<Fri Feb 15, 2019>
Add
  • flatten in extra.

5.1.3 Version 0.1.0

Data
<Wed Feb 06, 2019>
Commemorate Version
First Release.

Date: 2019-01-30 Wed 00:00

Author: Nasy

Created: 2019-03-10 Sun 15:50

PK!ˑ README.org#+OPTIONS: ':nil *:t -:t ::t <:t H:3 \n:nil ^:{} arch:headline author:t #+OPTIONS: broken-links:nil c:nil creator:nil d:(not "LOGBOOK") date:t e:t #+OPTIONS: email:nil f:t inline:t num:t p:nil pri:nil prop:nil stat:t tags:t #+OPTIONS: tasks:t tex:t timestamp:t title:t toc:t todo:nil |:t #+TITLE: Nalude #+DATE: <2019-01-30 Wed> #+AUTHOR: Nasy #+EMAIL: nasyxx+nalude@gmail.com #+LANGUAGE: en #+SELECT_TAGS: export #+EXCLUDE_TAGS: noexport #+CREATOR: Emacs 26.1.91 (Org mode 9.1.9) #+SETUPFILE: https://fniessen.github.io/org-html-themes/setup/theme-readtheorg.setup * Prologue I like Haskell, also hope some of the prelude functions in Haskell can be used in Python. Wish you enjoy coding with nalude. * Nalude Nalude is a standard module, which is inspired by Haskell's Prelude. Thus, nalude is also a library of functional programming. Nalude doesn't explicitly distinguish between Applicative's or monadic function since they are not well differentiated in the basic structure of Python. Of course, the main reason is that I am too fresh. The following functions, Nalude tries to implement: 1. Folds and Traversals 2. Lists 3. Miscellaneous 4. Specials 5. Strings 6. Tuples 7. Zip and Unzip At the same time, it also implements some functions which are only available in Python and are included in `extra`. * Structure of Functions ** Folds and Traversals + foldr(f: Callable[[b, a], b], init: b, t: Sequence[a]) :: Right-associative fold of a sequence. + foldl(f, init, t) :: Left-associative fold of an iterable. The same as ~reduce~. + foldr1(f, t) :: A variant of foldr without base case. + foldl1(f, t) :: A variant of foldl without base case. + product(nums) :: Computes the product of the numbers. + (HELP WANTED) traverse :: Map each element of a structure to an action, evaluate these actions from left to right, and collect the results. + (HELP WANTED) sequence :: Evaluate each actions in the structure from left to right, and collect the results. ** Lists + head(xs) :: Extract the first element of an iterable. + last(xs) :: Extract the last element of an iterable. + null(xs) :: Test whether the sequence is empty. + Infinite lists - iterate(f, x) :: Yield a tuple of repeated applications of f to x. - repeat(x) :: Repeat x. - replicate(n, x) :: Return a list of length n with x the value of every element. - cycle(xs) :: Tie an iterable to infinite circuler one. - Sublists + tail(xs) :: Extract the elements after the head of a list. + init(xs) :: Extract all the elements of an iterable except the last one. + take(n, xs) :: Return the first n elements of sequence xs. + drop(n, xs) :: Return the remaining elements of xs after the first n elements. + splitat(n, xs) :: Return a tuple where the first element is xs prefix of length n and second element is the remainder of the sequence xs. + takewhile(p, xs) :: Return the longest prefix of xs of elements that satisfy predicate p. + dropwhile(p, xs) :: Return the suffix remaining after takewhile(p, xs). + (LAZY ONE HELP WANTED) span(p, xs) :: Equal to (takewhile(p, xs), dropwhile(p, xs)). + (LAZY ONE HELP WANTED) break_(p, xs) :: Equal to (takewhile(not_(p), xs), dropwhile(not_(p), xs)). ** Miscellaneous + id_(x) :: Identity function. + const(x, _) :: Evaluates to x for all inputs. + o(f1, f2) :: (.) Function composition + flip(f) :: Flip takes its two arguments into the reverse order of f. + until(p, f, x) :: Yield the result of applying f until p holds. ** String + lines(s) :: Break up a string into a list of strings at newline characters. + unlines(xs) :: The inverse operation of lines, append a newline to each. + words(s) :: Break a string up into a list of words, which were delimited by white space. + unwords(xs) :: The inverse operation of words, join words with space. ** Specials + not_(f) :: Boolean "not". + all_(p, xs) :: Determine whether all elements of the structure satisfy the p. + any_(p, xs) :: Determine whether sny elements of the structure satisfies the p. + concat(xss) :: The concatenation of all the elements of a container of Sequences. + concatmap(f, xss) :: Map a function over all the elements of a container and concatenate the resulting lists. ** Tuples + fst(t) :: Extract the first component of a tuple. + snd(t) :: Extract the second component of a tuple. + curry(f, a, b) :: Converts an uncurried function to a curried function. + uncurry(f, ab@(a, b)) :: Converts a curried function to a function on pairs. ** Zip and Unzip + zipwith(f, *seqs) :: Zipwith is map(f, zip), but f accept separate args instead of tuple + unzip(pairs) :: Transform an iterable of pairs into a tuple of sequence. (Not lazy) ** Extra + flatten(xs,*,ignore=(dict,)) :: Flatten iterables of iterable to a single iterable. It will ignore instances in ~ignore~ tuple. * Get Start ** Install #+begin_src zsh pip install nalude #+end_src * Epoligue ** History #+include: "CHANGELOG" :minlevel 3 PK! nalude/__init__.py#!/usr/bin/env python3 # -*- coding: utf-8 -*- r""" Life's pathetic, have fun ("▔□▔)/hi~♡ Nasy. Excited without bugs:: | * * | . . | . | * , | . | | * | |\___/| | ) -( . · | =\ - /= | )===( * | / - \ | |- | | / - \ 0.|.0 | NASY___\__( (__/_____(\=/)__+1s____________ | ______|____) )______|______|______|______|_ | ___|______( (____|______|______|______|____ | ______|____\_|______|______|______|______|_ | ___|______|______|______|______|______|____ | ______|______|______|______|______|______|_ | ___|______|______|______|______|______|____ author : Nasy https://nasy.moe date : Jan 30, 2019 email : Nasy filename : __init__.py project : nalude license : LGPL-3.0+ There are more things in heaven and earth, Horatio, than are dreamt. -- From "Hamlet" """ __version__ = "0.3.0" # Local Packages from .extra import flatten from .nalude import (o, fst, id_, snd, all_, any_, drop, flip, head, init, last, not_, null, span, tail, take, const, curry, cycle, foldl, foldr, lines, until, unzip, words, break_, concat, foldl1, foldr1, repeat, iterate, product, splitat, uncurry, unlines, unwords, zipwith, concatmap, dropwhile, replicate, takewhile,) if __name__ == "__main__": # Folds and Traversals assert foldl assert foldl1 assert foldr assert foldr1 assert product # Lists assert head assert last assert init assert tail assert null assert iterate assert repeat assert replicate assert cycle assert take assert drop assert splitat assert takewhile assert dropwhile assert span assert break_ # Miscellaneous assert id_ assert const assert flip assert o assert until # String assert lines assert unlines assert words assert unwords # Specials assert not_ assert all_ assert any_ assert concat assert concatmap # TUple assert fst assert snd assert curry assert uncurry # Zip and Unzip assert zipwith assert unzip # Extra assert flatten PK!6\\nalude/extra.py#!/usr/bin/env python3 # -*- coding: utf-8 -*- r""" Life's pathetic, have fun ("▔□▔)/hi~♡ Nasy. Excited without bugs:: | * * | . . | . | * , | . | | * | |\___/| | ) -( . · | =\ - /= | )===( * | / - \ | |- | | / - \ 0.|.0 | NASY___\__( (__/_____(\=/)__+1s____________ | ______|____) )______|______|______|______|_ | ___|______( (____|______|______|______|____ | ______|____\_|______|______|______|______|_ | ___|______|______|______|______|______|____ | ______|______|______|______|______|______|_ | ___|______|______|______|______|______|____ author : Nasy https://nasy.moe date : Feb 15, 2019 email : Nasy filename : extra.py project : nalude license : LGPL-3.0+ There are more things in heaven and earth, Horatio, than are dreamt. -- From "Hamlet" """ # Standard Library from typing import Type, Tuple, Iterable # Local Packages from .types import G, a def flatten(xs: a, *, ignore: Tuple[Type, ...] = (dict,)) -> G: """Flatten iterables of iterable to a single one. The true type of it is:: `T = Iterable[Untion[a, T]]` .""" if not (isinstance(xs, (str, *ignore)) or not isinstance(xs, Iterable)): for x in xs: for x_ in flatten(x, ignore=ignore): yield x_ else: yield xs PK!))nalude/nalude.py#!/usr/bin/env python3 # -*- coding: utf-8 -*- r""" Life's pathetic, have fun ("▔□▔)/hi~♡ Nasy. Excited without bugs:: | * * | . . | . | * , | . | | * | |\___/| | ) -( . · | =\ - /= | )===( * | / - \ | |- | | / - \ 0.|.0 | NASY___\__( (__/_____(\=/)__+1s____________ | ______|____) )______|______|______|______|_ | ___|______( (____|______|______|______|____ | ______|____\_|______|______|______|______|_ | ___|______|______|______|______|______|____ | ______|______|______|______|______|______|_ | ___|______|______|______|______|______|____ author : Nasy https://nasy.moe date : Jan 31, 2019 email : Nasy filename : nalude.py project : nalude license : LGPL-3.0+ There are more things in heaven and earth, Horatio, than are dreamt. -- From "Hamlet" """ # Standard Library from typing import List, Tuple, Callable, Iterable, Generator from functools import reduce # Local Packages from .types import G, Num, Predicate, a, b, c # ---------------------------------------------------------------------- # Folds and Traversals # ---------------------------------------------------------------------- def foldl(f: Callable[[b, a], b], init: b, t: Iterable[a]) -> b: """Left-associative fold of an iterable.""" return reduce(f, t, init) def foldr(f: Callable[[a, b], b], init: b, t: Iterable[a]) -> b: """Right-associative fold of an iterable.""" t_ = list(t) return reduce(flip(f), reversed(t_), init) def foldl1(f: Callable[[a, a], a], t: Iterable[a]) -> a: """Left-associative fold of an iterable. This is avariant of foldl without base case. """ t_ = iter(t) try: return reduce(f, t_, next(t_)) except StopIteration: raise IndexError("Iterable is Empty") def foldr1(f: Callable[[a, a], a], t: Iterable[a]) -> a: """Right-associative fold of an iterable. This is a variant of foldr without base case. """ t_ = iter(reversed(list(t))) try: return reduce(f, t_, next(t_)) except StopIteration: raise IndexError("Iterable is Empty") def product(nums: Iterable[Num]) -> Num: """Computes the product of the numbers.""" try: return foldl1(lambda b, a: a * b, nums) except IndexError: raise IndexError("Numbers are empty") # ---------------------------------------------------------------------- # Lists # ---------------------------------------------------------------------- def head(xs: Iterable[a]) -> a: """Extract the first element of an iterable.""" try: return next(iter(xs)) except StopIteration: raise IndexError("Iterable is empty.") def tail(xs: Iterable[a]) -> G: """Extract the elements after the head of an iterable.""" try: ixs = iter(xs) next(ixs) for x in ixs: yield x except StopIteration: raise IndexError("Iterable is empty.") def last(xs: Iterable[a]) -> a: """Extract the last element of an iterable.""" try: return next(iter(reversed(list(xs)))) except StopIteration: raise IndexError("Iterable is empty.") def init(xs: Iterable[a]) -> G: """Extract all the elements of an iterable except the last one.""" ixs = iter(xs) try: x_ = next(ixs) n = True while n: try: x = next(ixs) yield x_ x_ = x except StopIteration: n = False except StopIteration: raise IndexError("Iterable is empty.") def null(l: Iterable[a]) -> bool: """Test whether the sequence is empty.""" try: next(iter(l)) return False except StopIteration: return True def iterate(f: Callable[[a], a], x: a) -> G: """Yield a tuple of repeated applications of f to x.""" while True: yield x x = f(x) def repeat(x: a) -> G: """Repeat x.""" while True: yield x def replicate(n: int, x: a) -> G: """Return a iterator of length n with x the value of every element.""" for _ in range(n): yield x def cycle(xs: Iterable[a]) -> G: """Tie an iterable to infinite circuler one.""" xs_ = [] # if x is a finite iterator, this can save the value. ixs = iter(xs) try: x = next(ixs) yield x xs_.append(x) except StopIteration: raise IndexError("Iterable is empty.") for x in ixs: yield x xs_.append(x) while True: for x in xs_: yield x def take(n: int, xs: Iterable[a]) -> G: """Return the first n elements of sequence xs.""" for _, x in zip(range(n), xs): yield x def drop(n: int, xs: Iterable[a]) -> G: """Return the remaining elements of xs after the first n elements.""" ixs = iter(xs) try: for _ in range(n): next(ixs) while True: yield next(ixs) except StopIteration: pass def splitat(n: int, xs: Iterable[a]) -> Tuple[G, G]: """Equal to (take(n, xs), drop(n, xs)). Return a tuple where the first element is xs prefix of length n and second element is the remainder of the sequence xs. """ ixs = iter(xs) return (i for i in list(take(n, ixs))), (i for i in ixs) def takewhile(p: Predicate, xs: Iterable[a]) -> G: """Return the longest prefix of xs of elements that satisfy predicate p.""" for x in xs: if p(x): yield x else: break def dropwhile(p: Predicate, xs: Iterable[a]) -> G: """Returns the suffix remaining after takewhile(p, xs).""" ixs = iter(xs) for x in ixs: if not p(x): yield x break for x in ixs: yield x def span(p: Predicate, xs: Iterable[a]) -> Tuple[List[a], List[a]]: """Equal to (takewhile(p, xs), dropwhile(p, xs)). Note: Not lazy.""" lxs = list(xs) return list(takewhile(p, lxs)), list(dropwhile(p, lxs)) def break_(p: Predicate, xs: Iterable[a]) -> Tuple[List[a], List[a]]: """Equal to (takewhile(not_(p), xs), dropwhile(not_(p), xs)). Note: Not lazy.""" lxs = list(xs) return list(takewhile(not_(p), lxs)), list(dropwhile(not_(p), lxs)) # ---------------------------------------------------------------------- # Miscellaneous # ---------------------------------------------------------------------- def id_(x: a) -> a: """Identity function.""" return x def const(x: a, _: b) -> a: """Evaluates to x for all inputs.""" return x def o(f1: Callable[[b], c], f2: Callable[[a], b]) -> Callable[[a], c]: """Function composition. >>> o(f1, f2)(a) == f1(f2(a)) """ return lambda a_: f1(f2(a_)) def flip(f: Callable[[a, b], c]) -> Callable[[b, a], c]: """Flip takes its two arguments into the reverse order of f. >>> flip(f)(b, a) == f(a, b) """ return lambda b_, a_: f(a_, b_) def until(p: Predicate, f: Callable[[a], a], x: a) -> a: """Yields the result of applying f until p holds.""" return p(x) and x or until(p, f, f(x)) # ---------------------------------------------------------------------- # Strings # ---------------------------------------------------------------------- def lines(s: str) -> List[str]: """Break up a string into a list of strings at newline characters.""" return s.splitlines() def unlines(xs: Iterable[str]) -> str: """The inverse operation of lines, append a newline to each.""" return "\n".join(xs) + ("\n" if xs else "") def words(s: str) -> List[str]: """Breaks a string up into a list of words, which were delimited by white space.""" return s.split() def unwords(xs: Iterable[str]) -> str: """The inverse operation of words, join words with space.""" return " ".join(xs) # ---------------------------------------------------------------------- # Specials # ---------------------------------------------------------------------- def not_(f: Callable[..., bool]) -> Callable[..., bool]: """Boolean "not".""" def _wrap(*args: a, **kwds: b) -> bool: """Wrapper of not_.""" return not f(*args, **kwds) return _wrap def all_(p: Predicate, xs: Iterable[a]) -> bool: """Determine whether all elements of the structure satisfy the p.""" return all(map(p, xs)) def any_(p: Predicate, xs: Iterable[a]) -> bool: """Determine whether any element of the structure satisfies the p.""" return any(map(p, xs)) def concat(xss: Iterable[Iterable[a]]) -> G: """The concatenation of all the elements of a container of Iterables.""" for xs in xss: for x in xs: yield x def concatmap( f: Callable[[Iterable[a]], Iterable[b]], xss: Iterable[Iterable[a]] ) -> Generator[b, None, None]: """Map a function over all the elements of a container and concatenate the resulting lists.""" for xs in xss: for x in f(xs): yield x # ---------------------------------------------------------------------- # Tuples # ---------------------------------------------------------------------- def fst(t: Tuple[a, b]) -> a: """Extract the first component of a tuple.""" return t[0] def snd(t: Tuple[a, b]) -> b: """Extract the second component of a tuple.""" return t[1] def curry(f: Callable[[Tuple[a, b]], c], a_: a, b_: b) -> c: """Converts an uncurried function to a curried function.""" return f((a_, b_)) def uncurry(f: Callable[[a, b], c], ab: Tuple[a, b]) -> c: """Converts a curried function to a function on pairs.""" a_, b_ = ab return f(a_, b_) # ---------------------------------------------------------------------- # Zip and Unzip # ---------------------------------------------------------------------- def zipwith( f: Callable[..., c], *seqs: Iterable[a] ) -> Generator[c, None, None]: """Zipwith is map(f, zip), but f accept separate args instead of tuple""" for zseq in zip(*seqs): yield f(*zseq) def unzip(pairs: Iterable[Tuple[a, ...]]) -> Tuple[Iterable[a], ...]: """Transform an iterable of pairs into a tuple of sequence. Note: Not lazy.""" pairs = list(pairs) if pairs: return tuple( [pair[i] for pair in pairs] for i in range(len(head(pairs))) ) return tuple() PK!uBnalude/types.py#!/usr/bin/env python3 # -*- coding: utf-8 -*- r""" Life's pathetic, have fun ("▔□▔)/hi~♡ Nasy. Excited without bugs:: | * * | . . | . | * , | . | | * | |\___/| | ) -( . · | =\ - /= | )===( * | / - \ | |- | | / - \ 0.|.0 | NASY___\__( (__/_____(\=/)__+1s____________ | ______|____) )______|______|______|______|_ | ___|______( (____|______|______|______|____ | ______|____\_|______|______|______|______|_ | ___|______|______|______|______|______|____ | ______|______|______|______|______|______|_ | ___|______|______|______|______|______|____ author : Nasy https://nasy.moe date : Jan 31, 2019 email : Nasy filename : types.py project : nalude license : LGPL-3.0+ There are more things in heaven and earth, Horatio, than are dreamt. -- From "Hamlet" """ # Standard Library from typing import TypeVar, Callable, Generator a = TypeVar("a") b = TypeVar("b") c = TypeVar("c") t = TypeVar("t") G = Generator[a, None, None] Num = TypeVar("Num", int, float, complex) Predicate = Callable[[a], bool] __all__ = ["a", "b", "c", "t", "G", "Num", "Predicate"] PK!l5 5 poetry.lock[[package]] category = "dev" description = "Atomic file writes." name = "atomicwrites" optional = false python-versions = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*" version = "1.3.0" [[package]] category = "dev" description = "Classes Without Boilerplate" name = "attrs" optional = false python-versions = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*" version = "19.1.0" [package.extras] dev = ["coverage", "hypothesis", "pympler", "pytest", "six", "zope.interface", "sphinx", "pre-commit"] docs = ["sphinx", "zope.interface"] tests = ["coverage", "hypothesis", "pympler", "pytest", "six", "zope.interface"] [[package]] category = "dev" description = "Cross-platform colored terminal text." marker = "sys_platform == \"win32\"" name = "colorama" optional = false python-versions = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*" version = "0.4.1" [[package]] category = "dev" description = "More routines for operating on iterables, beyond itertools" name = "more-itertools" optional = false python-versions = ">=3.4" version = "6.0.0" [[package]] category = "dev" description = "plugin and hook calling mechanisms for python" name = "pluggy" optional = false python-versions = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*" version = "0.9.0" [package.extras] dev = ["pre-commit", "tox"] [[package]] category = "dev" description = "library with cross-python path, ini-parsing, io, code, log facilities" name = "py" optional = false python-versions = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*" version = "1.8.0" [[package]] category = "dev" description = "pytest: simple powerful testing with Python" name = "pytest" optional = false python-versions = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*" version = "3.10.1" [package.dependencies] atomicwrites = ">=1.0" attrs = ">=17.4.0" colorama = "*" more-itertools = ">=4.0.0" pluggy = ">=0.7" py = ">=1.5.0" setuptools = "*" six = ">=1.10.0" [[package]] category = "dev" description = "Python 2 and 3 compatibility utilities" name = "six" optional = false python-versions = ">=2.6, !=3.0.*, !=3.1.*" version = "1.12.0" [metadata] content-hash = "f211e76d6cc74c3efb4396cf22c9a08d4325d2cb8741022c782cebfcb662ee21" python-versions = "^3.6" [metadata.hashes] atomicwrites = ["03472c30eb2c5d1ba9227e4c2ca66ab8287fbfbbda3888aa93dc2e28fc6811b4", "75a9445bac02d8d058d5e1fe689654ba5a6556a1dfd8ce6ec55a0ed79866cfa6"] attrs = ["69c0dbf2ed392de1cb5ec704444b08a5ef81680a61cb899dc08127123af36a79", "f0b870f674851ecbfbbbd364d6b5cbdff9dcedbc7f3f5e18a6891057f21fe399"] colorama = ["05eed71e2e327246ad6b38c540c4a3117230b19679b875190486ddd2d721422d", "f8ac84de7840f5b9c4e3347b3c1eaa50f7e49c2b07596221daec5edaabbd7c48"] more-itertools = ["0125e8f60e9e031347105eb1682cef932f5e97d7b9a1a28d9bf00c22a5daef40", "590044e3942351a1bdb1de960b739ff4ce277960f2425ad4509446dbace8d9d1"] pluggy = ["19ecf9ce9db2fce065a7a0586e07cfb4ac8614fe96edf628a264b1c70116cf8f", "84d306a647cc805219916e62aab89caa97a33a1dd8c342e87a37f91073cd4746"] py = ["64f65755aee5b381cea27766a3a147c3f15b9b6b9ac88676de66ba2ae36793fa", "dc639b046a6e2cff5bbe40194ad65936d6ba360b52b3c3fe1d08a82dd50b5e53"] pytest = ["3f193df1cfe1d1609d4c583838bea3d532b18d6160fd3f55c9447fdca30848ec", "e246cf173c01169b9617fc07264b7b1316e78d7a650055235d6d897bc80d9660"] six = ["3350809f0555b11f552448330d0b52d5f24c91a322ea4a15ef22629740f3761c", "d16a0141ec1a18405cd4ce8b4613101da75da0e9a7aec5bdd4fa804d0e0eba73"] PK!2 nalude-0.3.0.dist-info/LICENSE GNU LESSER GENERAL PUBLIC LICENSE Version 3, 29 June 2007 Copyright (C) 2007 Free Software Foundation, Inc. Everyone is permitted to copy and distribute verbatim copies of this license document, but changing it is not allowed. This version of the GNU Lesser General Public License incorporates the terms and conditions of version 3 of the GNU General Public License, supplemented by the additional permissions listed below. 0. Additional Definitions. As used herein, "this License" refers to version 3 of the GNU Lesser General Public License, and the "GNU GPL" refers to version 3 of the GNU General Public License. "The Library" refers to a covered work governed by this License, other than an Application or a Combined Work as defined below. An "Application" is any work that makes use of an interface provided by the Library, but which is not otherwise based on the Library. Defining a subclass of a class defined by the Library is deemed a mode of using an interface provided by the Library. A "Combined Work" is a work produced by combining or linking an Application with the Library. The particular version of the Library with which the Combined Work was made is also called the "Linked Version". The "Minimal Corresponding Source" for a Combined Work means the Corresponding Source for the Combined Work, excluding any source code for portions of the Combined Work that, considered in isolation, are based on the Application, and not on the Linked Version. The "Corresponding Application Code" for a Combined Work means the object code and/or source code for the Application, including any data and utility programs needed for reproducing the Combined Work from the Application, but excluding the System Libraries of the Combined Work. 1. Exception to Section 3 of the GNU GPL. You may convey a covered work under sections 3 and 4 of this License without being bound by section 3 of the GNU GPL. 2. Conveying Modified Versions. If you modify a copy of the Library, and, in your modifications, a facility refers to a function or data to be supplied by an Application that uses the facility (other than as an argument passed when the facility is invoked), then you may convey a copy of the modified version: a) under this License, provided that you make a good faith effort to ensure that, in the event an Application does not supply the function or data, the facility still operates, and performs whatever part of its purpose remains meaningful, or b) under the GNU GPL, with none of the additional permissions of this License applicable to that copy. 3. Object Code Incorporating Material from Library Header Files. The object code form of an Application may incorporate material from a header file that is part of the Library. You may convey such object code under terms of your choice, provided that, if the incorporated material is not limited to numerical parameters, data structure layouts and accessors, or small macros, inline functions and templates (ten or fewer lines in length), you do both of the following: a) Give prominent notice with each copy of the object code that the Library is used in it and that the Library and its use are covered by this License. b) Accompany the object code with a copy of the GNU GPL and this license document. 4. Combined Works. You may convey a Combined Work under terms of your choice that, taken together, effectively do not restrict modification of the portions of the Library contained in the Combined Work and reverse engineering for debugging such modifications, if you also do each of the following: a) Give prominent notice with each copy of the Combined Work that the Library is used in it and that the Library and its use are covered by this License. b) Accompany the Combined Work with a copy of the GNU GPL and this license document. c) For a Combined Work that displays copyright notices during execution, include the copyright notice for the Library among these notices, as well as a reference directing the user to the copies of the GNU GPL and this license document. d) Do one of the following: 0) Convey the Minimal Corresponding Source under the terms of this License, and the Corresponding Application Code in a form suitable for, and under terms that permit, the user to recombine or relink the Application with a modified version of the Linked Version to produce a modified Combined Work, in the manner specified by section 6 of the GNU GPL for conveying Corresponding Source. 1) Use a suitable shared library mechanism for linking with the Library. A suitable mechanism is one that (a) uses at run time a copy of the Library already present on the user's computer system, and (b) will operate properly with a modified version of the Library that is interface-compatible with the Linked Version. e) Provide Installation Information, but only if you would otherwise be required to provide such information under section 6 of the GNU GPL, and only to the extent that such information is necessary to install and execute a modified version of the Combined Work produced by recombining or relinking the Application with a modified version of the Linked Version. (If you use option 4d0, the Installation Information must accompany the Minimal Corresponding Source and Corresponding Application Code. If you use option 4d1, you must provide the Installation Information in the manner specified by section 6 of the GNU GPL for conveying Corresponding Source.) 5. Combined Libraries. You may place library facilities that are a work based on the Library side by side in a single library together with other library facilities that are not Applications and are not covered by this License, and convey such a combined library under terms of your choice, if you do both of the following: a) Accompany the combined library with a copy of the same work based on the Library, uncombined with any other library facilities, conveyed under the terms of this License. b) Give prominent notice with the combined library that part of it is a work based on the Library, and explaining where to find the accompanying uncombined form of the same work. 6. Revised Versions of the GNU Lesser General Public License. The Free Software Foundation may publish revised and/or new versions of the GNU Lesser General Public License from time to time. Such new versions will be similar in spirit to the present version, but may differ in detail to address new problems or concerns. Each version is given a distinguishing version number. If the Library as you received it specifies that a certain numbered version of the GNU Lesser General Public License "or any later version" applies to it, you have the option of following the terms and conditions either of that published version or of any later version published by the Free Software Foundation. If the Library as you received it does not specify a version number of the GNU Lesser General Public License, you may choose any version of the GNU Lesser General Public License ever published by the Free Software Foundation. If the Library as you received it specifies that a proxy can decide whether future versions of the GNU Lesser General Public License shall apply, that proxy's public statement of acceptance of any version is permanent authorization for you to choose that version for the Library.PK!Hu)GTUnalude-0.3.0.dist-info/WHEEL HM K-*ϳR03rOK-J,/R(O-)$qzd&Y)r$UV&UrPK!HdUq ?nalude-0.3.0.dist-info/METADATAYkS7BCfZK&R S0@L2EJ[II{sΔN`uo15tLi.ŔflJMɠ?"˨ZO цd2.R'B+pMPϚ\)A˜\O,l_P^@9{}5Oz)U$r'|IaRMe(OuQ_p*XwrpqxyRy锼 'y|OfLkk&)*”GØHERjwH5a2~ Fxvid8:OOn*"S(+U!"4A;ÃI4`n@x%Xh rtM=- (vVk'I<Ъ}uD'8L虷 E  ,Q̎ĝmCʼuAD~(#z9  t| e!7*9xL04M0a7v2U`ESN1e"`3zx\ڄ8bICM8!|sJxbK,Dz++G 7,dΈp2 F<5EC"*HH~|zAֲ L|k~ 䡼2җxm p5 =\hgPO=BGiZXsyPʀX2-~6r@Tn5!@S!3K1S`PO4ø B&Xb c$L:pgK=`͖!&]a- K DŨ%YPC.͈2H`,[ Ld%hǛ FA/"NXmT4,2v]6[uz}j 81 CoܸtUiWu92hJy0T-Vi5AG?m|}=֥p[<K+'ABbI )#!7T@RaV^>.ك&!Xd8 ;P45_| &WEr;'/Qmeaf67>/%a:ȴe>Y^,W R, !%o|8=?Bی0Q(DzJ9ڜ{6D`(‹, Գ鏠`ðVAUeЪR5ְk{2֮\p#Qq FENUC•6h5*eGXE%-r!,7ku!qo@0+0gP@Y%pc1~C#8Aoky򱖡ؔ9@7 W+̵5ZF>>M:JYΚ`] *ɨqnPk'8K#Z7MAmma| X( k}_],u3u8VzSPd]kYjkS(oeؖށ"E]%|ժ hJhI_mzNm00%mQHcնleBCwdTso "Au}7۔ڙ|<'m̩h9 )G6*Bاᐦ딵RW+nuP/R (nRy \ĸ)u #wv.u+v&0:A$;ɰGՖ$wb);|h"Y¬T• թ ZMJbl7Y4v[%pEjcf#n,crt7*)r7Q5Fi@-D ) d}ӻa[#U`VA#NR}LjXYnh%f)ϸqW  Qop K"aٰIe5#͈~9mɻZMʔǝ(Vs1p)>jOHv#BX?*{e"D3` WFr3-KǭwFC#n+-B$#YIWLwv@ ڙ+"ُB5mȯXbDC"|~$`e-b)5EGFOs}dxNu؜y$Hj;rC֡WW,$ÃPe=lXֻ'[?G?Y2iѠ`\aWPK!H :Tnalude-0.3.0.dist-info/RECORDuɒ@6xb"΅@RYQ|)Oş)))C 5aP_ᮿYyFK,F Ox7)]C0`8AqkuU3QvUB.{P[BZ[TjFe6UM !I\ݦGTÑɐJXI@Wu>fur!P#=Ci]!lG%"v5Sk'?D`/L Jc <í dRp[1Hȟ/ូMV{㵱2!'4qajt;oM9GUx=JyQ+\%^M6ܧeդl74*pͮNF:O}gG2Gs;H@o!%(2q4my#r&Ի)2c!X|xi |ρ_Y_PnTY+Ho