{ "info": { "author": "Pedro Rodriguez", "author_email": "ski.rodriguez@gmail.com", "bugtrack_url": null, "classifiers": [ "Development Status :: 4 - Beta", "Intended Audience :: Developers", "License :: OSI Approved :: MIT License", "Natural Language :: English", "Operating System :: OS Independent", "Programming Language :: Python :: 2.7", "Programming Language :: Python :: 3.3", "Programming Language :: Python :: 3.4", "Programming Language :: Python :: 3.5", "Programming Language :: Python :: Implementation :: CPython", "Programming Language :: Python :: Implementation :: PyPy", "Topic :: Software Development :: Libraries :: Python Modules" ], "description": "PyFunctional\r\n============\r\n\r\n|TravisCI| |Coverage by codecov.io| |ReadTheDocs| |Latest Version| |Gitter|\r\n\r\nNote: ``ScalaFunctional`` is now ``PyFunctional``, see `RFC `__ for details\r\n\r\nIntroduction\r\n------------\r\n\r\n``PyFunctional`` is a Python package that makes working with data easy. It takes inspiration from several sources that include Scala collections, Apache Spark RDDs, Microsoft LINQ and more generally functional programming. It also offers native reading and writing of data formats such as text, csv,\r\nand json files. Support for SQLite3, other databases, and compressed files is planned for the next release.\r\n\r\nThe combination of these ideas makes ``PyFunctional`` a great choice for declarative transformation, creating pipelines, and data analysis.\r\n\r\n`Original blog post for ScalaFunctional `__\r\n\r\nInstallation\r\n------------\r\n\r\n``PyFunctional`` is available on `pypi `__ and can be installed by running:\r\n\r\n.. code:: bash\r\n\r\n # Install from command line\r\n $ pip install pyfunctional\r\n\r\nThen in python run: ``from functional import seq``\r\n\r\nExamples\r\n--------\r\n\r\n``PyFunctional`` is useful for many tasks, and can natively open several common file types. Here are a few examples of what you can do.\r\n\r\nSimple Example\r\n~~~~~~~~~~~~~~\r\n\r\n.. code:: python\r\n\r\n from functional import seq\r\n\r\n seq(1, 2, 3, 4)\\\r\n .map(lambda x: x * 2)\\\r\n .filter(lambda x: x > 4)\\\r\n .reduce(lambda x, y: x + y)\r\n # 14\r\n\r\nStreams, Transformations and Actions\r\n~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\r\n\r\n``PyFunctional`` has three types of functions:\r\n\r\n1. Streams: read data for use by the collections API.\r\n2. Transformations: transform data from streams with functions such as ``map``, ``flat_map``, and ``filter``\r\n3. Actions: These cause a series of transformations to evaluate to a concrete value. ``to_list``, ``reduce``, and ``to_dict`` are examples of actions.\r\n\r\nIn the expression ``seq(1, 2, 3).map(lambda x: x * 2).reduce(lambda x, y: x + y)``, ``seq`` is the stream, ``map`` is the transformation, and ``reduce`` is the action.\r\n\r\nFiltering a list of account transactions\r\n~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\r\n\r\n.. code:: python\r\n\r\n from functional import seq\r\n from collections import namedtuple\r\n\r\n Transaction = namedtuple('Transaction', 'reason amount')\r\n transactions = [\r\n Transaction('github', 7),\r\n Transaction('food', 10),\r\n Transaction('coffee', 5),\r\n Transaction('digitalocean', 5),\r\n Transaction('food', 5),\r\n Transaction('riotgames', 25),\r\n Transaction('food', 10),\r\n Transaction('amazon', 200),\r\n Transaction('paycheck', -1000)\r\n ]\r\n\r\n # Using the Scala/Spark inspired APIs\r\n food_cost = seq(transactions)\\\r\n .filter(lambda x: x.reason == 'food')\\\r\n .map(lambda x: x.amount).sum()\r\n\r\n # Using the LINQ inspired APIs\r\n food_cost = seq(transactions)\\\r\n .where(lambda x: x.reason == 'food')\\\r\n .select(lambda x: x.amount).sum()\r\n\r\n # Using ScalaFunctional with fn\r\n from fn import _\r\n food_cost = seq(transactions).filter(_.reason == 'food').map(_.amount).sum()\r\n\r\nWord Count and Joins\r\n~~~~~~~~~~~~~~~~~~~~\r\n\r\nThe account transactions example could be done easily in pure python using list comprehensions. To show some of the things ``PyFunctional`` excels at, take a look at a couple of word count examples.\r\n\r\n.. code:: python\r\n\r\n words = 'I dont want to believe I want to know'.split(' ')\r\n seq(words).map(lambda word: (word, 1)).reduce_by_key(lambda x, y: x + y)\r\n # [('dont', 1), ('I', 2), ('to', 2), ('know', 1), ('want', 2), ('believe', 1)]\r\n\r\nIn the next example we have chat logs formatted in `json lines (jsonl) `__ which contain messages and metadata. A typical jsonl file will have one valid json on each line of a file. Below are a few lines out of ``examples/chat_logs.jsonl``.\r\n\r\n.. code:: json\r\n\r\n {\"message\":\"hello anyone there?\",\"date\":\"10/09\",\"user\":\"bob\"}\r\n {\"message\":\"need some help with a program\",\"date\":\"10/09\",\"user\":\"bob\"}\r\n {\"message\":\"sure thing. What do you need help with?\",\"date\":\"10/09\",\"user\":\"dave\"}\r\n\r\n.. code:: python\r\n\r\n from operator import add\r\n import re\r\n messages = seq.jsonl('examples/chat_lots.jsonl')\r\n\r\n # Split words on space and normalize before doing word count\r\n def extract_words(message):\r\n return re.sub('[^0-9a-z ]+', '', message.lower()).split(' ')\r\n\r\n\r\n word_counts = messages\\\r\n .map(lambda log: extract_words(log['message']))\\\r\n .flatten().map(lambda word: (word, 1))\\\r\n .reduce_by_key(add).order_by(lambda x: x[1])\r\n\r\nNext, lets continue that example but introduce a json database of users from ``examples/users.json``. In the previous example we showed how ``PyFunctional`` can do word counts, in the next example lets show how ``PyFunctional`` can join different data sources.\r\n\r\n.. code:: python\r\n\r\n # First read the json file\r\n users = seq.json('examples/users.json')\r\n #[('sarah',{'date_created':'08/08','news_email':True,'email':'sarah@gmail.com'}),...]\r\n\r\n email_domains = users.map(lambda u: u[1]['email'].split('@')[1]).distinct()\r\n # ['yahoo.com', 'python.org', 'gmail.com']\r\n\r\n # Join users with their messages\r\n message_tuples = messages.group_by(lambda m: m['user'])\r\n data = users.inner_join(message_tuples)\r\n # [('sarah',\r\n # (\r\n # {'date_created':'08/08','news_email':True,'email':'sarah@gmail.com'},\r\n # [{'date':'10/10','message':'what is a...','user':'sarah'}...]\r\n # )\r\n # ),...]\r\n\r\n # From here you can imagine doing more complex analysis\r\n\r\nCSV, Aggregate Functions, and Set functions\r\n~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\r\n\r\nIn ``examples/camping_purchases.csv`` there are a list of camping purchases. Lets do some cost analysis and compare it the required camping gear list stored in ``examples/gear_list.txt``.\r\n\r\n.. code:: python\r\n\r\n purchases = seq.csv('examples/camping_purchases.csv')\r\n total_cost = purchases.select(lambda row: int(row[2])).sum()\r\n # 1275\r\n\r\n most_expensive_item = purchases.max_by(lambda row: int(row[2]))\r\n # ['4', 'sleeping bag', ' 350']\r\n\r\n purchased_list = purchases.select(lambda row: row[1])\r\n gear_list = seq.open('examples/gear_list.txt').map(lambda row: row.strip())\r\n missing_gear = gear_list.difference(purchased_list)\r\n # ['water bottle','gas','toilet paper','lighter','spoons','sleeping pad',...]\r\n\r\nIn addition to the aggregate functions shown above (``sum`` and ``max_by``) there are many more. Similarly, there are several more set like functions in addition to ``difference``.\r\n\r\nReading/Writing SQLite3\r\n~~~~~~~~~~~~~~~~~~~~~~~\r\n\r\n``PyFunctional`` can read and write to SQLite3 database files. In the example below, users are read from ``examples/users.db`` which stores them as rows with columns ``id:Int`` and ``name:String``.\r\n\r\n.. code:: python\r\n\r\n db_path = 'examples/users.db'\r\n users = seq.sqlite3(db_path, 'select * from user').to_list()\r\n # [(1, 'Tom'), (2, 'Jack'), (3, 'Jane'), (4, 'Stephan')]]\r\n\r\n sorted_users = seq.sqlite3(db_path, 'select * from user order by name').to_list()\r\n # [(2, 'Jack'), (3, 'Jane'), (4, 'Stephan'), (1, 'Tom')]\r\n\r\nWriting to a SQLite3 database is similarly easy\r\n\r\n.. code:: python\r\n\r\n import sqlite3\r\n from collections import namedtuple\r\n\r\n with sqlite3.connect(':memory:') as conn:\r\n conn.execute('CREATE TABLE user (id INT, name TEXT)')\r\n conn.commit()\r\n User = namedtuple('User', 'id name')\r\n \r\n # Write using a specific query\r\n seq([(1, 'pedro'), (2, 'fritz')]).to_sqlite3(conn, 'INSERT INTO user (id, name) VALUES (?, ?)')\r\n \r\n # Write by inserting values positionally from a tuple/list into named table\r\n seq([(3, 'sam'), (4, 'stan')]).to_sqlite3(conn, 'user')\r\n \r\n # Write by inferring schema from namedtuple\r\n seq([User(name='tom', id=5), User(name='keiga', id=6)]).to_sqlite3(conn, 'user')\r\n \r\n # Write by inferring schema from dict\r\n seq([dict(name='david', id=7), dict(name='jordan', id=8)]).to_sqlite3(conn, 'user')\r\n \r\n # Read everything back to make sure it wrote correctly\r\n print(list(conn.execute('SELECT * FROM user')))\r\n \r\n # [(1, 'pedro'), (2, 'fritz'), (3, 'sam'), (4, 'stan'), (5, 'tom'), (6, 'keiga'), (7, 'david'), (8, 'jordan')]\r\n\r\nWriting to files\r\n~~~~~~~~~~~~~~~~\r\n\r\nJust as ``PyFunctional`` can read from ``csv``, ``json``, ``jsonl``, ``sqlite3``, and text files, it can also write them. For complete API documentation see the collections API table or the official docs.\r\n\r\nDocumentation\r\n-------------\r\n\r\nSummary documentation is below and full documentation is at `scalafunctional.readthedocs.org `__.\r\n\r\nStreams API\r\n~~~~~~~~~~~\r\n\r\nAll of ``PyFunctional`` streams can be accessed through the ``seq`` object. The primary way to create a stream is by calling ``seq`` with an iterable. The ``seq`` callable is smart and is able to accept multiple types of parameters as shown in the examples below.\r\n\r\n.. code:: python\r\n\r\n # Passing a list\r\n seq([1, 1, 2, 3]).to_set()\r\n # [1, 2, 3]\r\n\r\n # Passing direct arguments\r\n seq(1, 1, 2, 3).map(lambda x: x).to_list()\r\n # [1, 1, 2, 3]\r\n\r\n # Passing a single value\r\n seq(1).map(lambda x: -x).to_list()\r\n # [-1]\r\n\r\n``seq`` also provides entry to other streams as attribute functions as shown below.\r\n\r\n.. code:: python\r\n\r\n # number range\r\n seq.range(10)\r\n\r\n # text file\r\n seq.open('filepath')\r\n\r\n # json file\r\n seq.json('filepath')\r\n\r\n # jsonl file\r\n seq.jsonl('filepath')\r\n\r\n # csv file\r\n seq.csv('filepath')\r\n\r\n # sqlite3 db and sql query\r\n seq.sqlite3('filepath', 'select * from data')\r\n\r\nFor more information on the parameters that these functions can take, reference the `streams documentation `__\r\n\r\nTransformations and Actions APIs\r\n~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\r\n\r\nBelow is the complete list of functions which can be called on a stream object from ``seq``. For complete documentation reference `transformation and actions API `__.\r\n\r\n+-------------------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+------------------+\r\n| Function | Description | Type |\r\n+===============================================================================+==========================================================================================================================================================================================================+==================+\r\n| ``map(func)/select(func)`` | Maps ``func`` onto elements of sequence | transformation |\r\n+-------------------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+------------------+\r\n| ``filter(func)/where(func)`` | Filters elements of sequence to only those where ``func(element)`` is ``True`` | transformation |\r\n+-------------------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+------------------+\r\n| ``filter_not(func)`` | Filters elements of sequence to only those where ``func(element)`` is ``False`` | transformation |\r\n+-------------------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+------------------+\r\n| ``flatten()`` | Flattens sequence of lists to a single sequence | transformation |\r\n+-------------------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+------------------+\r\n| ``flat_map(func)`` | ``func`` must return an iterable. Maps ``func`` to each element, then merges the result to one flat sequence | transformation |\r\n+-------------------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+------------------+\r\n| ``group_by(func)`` | Groups sequence into ``(key, value)`` pairs where ``key=func(element)`` and ``value`` is from the original sequence | transformation |\r\n+-------------------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+------------------+\r\n| ``group_by_key()`` | Groups sequence of ``(key, value)`` pairs by ``key`` | transformation |\r\n+-------------------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+------------------+\r\n| ``reduce_by_key(func)`` | Reduces list of ``(key, value)`` pairs using ``func`` | transformation |\r\n+-------------------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+------------------+\r\n| ``union(other)`` | Union of unique elements in sequence and ``other`` | transformation |\r\n+-------------------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+------------------+\r\n| ``intersection(other)`` | Intersection of unique elements in sequence and ``other`` | transformation |\r\n+-------------------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+------------------+\r\n| ``difference(other)`` | New sequence with unique elements present in sequence but not in ``other`` | transformation |\r\n+-------------------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+------------------+\r\n| ``symmetric_difference(other)`` | New sequence with unique elements present in sequnce or ``other``, but not both | transformation |\r\n+-------------------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+------------------+\r\n| ``distinct()`` | Returns distinct elements of sequence. Elements must be hashable | transformation |\r\n+-------------------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+------------------+\r\n| ``distinct_by(func)`` | Returns distinct elements of sequence using ``func`` as a key | transformation |\r\n+-------------------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+------------------+\r\n| ``drop(n)`` | Drop the first ``n`` elements of the sequence | transformation |\r\n+-------------------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+------------------+\r\n| ``drop_right(n)`` | Drop the last ``n`` elements of the sequence | transformation |\r\n+-------------------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+------------------+\r\n| ``drop_while(func)`` | Drop elements while ``func`` evaluates to ``True``, then returns the rest | transformation |\r\n+-------------------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+------------------+\r\n| ``take(n)`` | Returns sequence of first ``n`` elements | transformation |\r\n+-------------------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+------------------+\r\n| ``take_while(func)`` | Take elements while ``func`` evaluates to ``True``, then drops the rest | transformation |\r\n+-------------------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+------------------+\r\n| ``init()`` | Returns sequence without the last element | transformation |\r\n+-------------------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+------------------+\r\n| ``tail()`` | Returns sequence without the first element | transformation |\r\n+-------------------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+------------------+\r\n| ``inits()`` | Returns consecutive inits of sequence | transformation |\r\n+-------------------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+------------------+\r\n| ``tails()`` | Returns consecutive tails of sequence | transformation |\r\n+-------------------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+------------------+\r\n| ``zip(other)`` | Zips the sequence with ``other`` | transformation |\r\n+-------------------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+------------------+\r\n| ``zip_with_index(start=0)`` | Zips the sequence with the index starting at ``start`` on the right side | transformation |\r\n+-------------------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+------------------+\r\n| ``enumerate(start=0)`` | Zips the sequence with the index starting at ``start`` on the left side | transformation |\r\n+-------------------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+------------------+\r\n| ``inner_join(other)`` | Returns inner join of sequence with other. Must be a sequence of ``(key, value)`` pairs | transformation |\r\n+-------------------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+------------------+\r\n| ``outer_join(other)`` | Returns outer join of sequence with other. Must be a sequence of ``(key, value)`` pairs | transformation |\r\n+-------------------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+------------------+\r\n| ``left_join(other)`` | Returns left join of sequence with other. Must be a sequence of ``(key, value)`` pairs | transformation |\r\n+-------------------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+------------------+\r\n| ``right_join(other)`` | Returns right join of sequence with other. Must be a sequence of ``(key, value)`` pairs | transformation |\r\n+-------------------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+------------------+\r\n| ``join(other, join_type='inner')`` | Returns join of sequence with other as specified by ``join_type``. Must be a sequence of ``(key, value)`` pairs | transformation |\r\n+-------------------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+------------------+\r\n| ``partition(func)`` | Partitions the sequence into elements which satisfy ``func(element)`` and those that don't | transformation |\r\n+-------------------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+------------------+\r\n| ``grouped(size)`` | Partitions the elements into groups of size ``size`` | transformation |\r\n+-------------------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+------------------+\r\n| ``sorted(key=None, reverse=False)/order_by(func)`` | Returns elements sorted according to python ``sorted`` | transformation |\r\n+-------------------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+------------------+\r\n| ``reverse()`` | Returns the reversed sequence | transformation |\r\n+-------------------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+------------------+\r\n| ``slice(start, until)`` | Sequence starting at ``start`` and including elements up to ``until`` | transformation |\r\n+-------------------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+------------------+\r\n| ``head()`` / ``first()`` | Returns first element in sequence | action |\r\n+-------------------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+------------------+\r\n| ``head_option()`` | Returns first element in sequence or ``None`` if its empty | action |\r\n+-------------------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+------------------+\r\n| ``last()`` | Returns last element in sequence | action |\r\n+-------------------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+------------------+\r\n| ``last_option()`` | Returns last element in sequence or ``None`` if its empty | action |\r\n+-------------------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+------------------+\r\n| ``len()`` / ``size()`` | Returns length of sequence | action |\r\n+-------------------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+------------------+\r\n| ``count(func)`` | Returns count of elements in sequence where ``func(element)`` is True | action |\r\n+-------------------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+------------------+\r\n| ``empty()`` | Returns ``True`` if the sequence has zero length | action |\r\n+-------------------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+------------------+\r\n| ``non_empty()`` | Returns ``True`` if sequence has non-zero length | action |\r\n+-------------------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+------------------+\r\n| ``all()`` | Returns ``True`` if all elements in sequence are truthy | action |\r\n+-------------------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+------------------+\r\n| ``exists(func)`` | Returns ``True`` if ``func(element)`` for any element in the sequence is ``True`` | action |\r\n+-------------------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+------------------+\r\n| ``for_all(func)`` | Returns ``True`` if ``func(element)`` is ``True`` for all elements in the sequence | action |\r\n+-------------------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+------------------+\r\n| ``find(func)`` | Returns the element that first evaluates ``func(element)`` to ``True`` | action |\r\n+-------------------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+------------------+\r\n| ``any()`` | Returns ``True`` if any element in sequence is truthy | action |\r\n+-------------------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+------------------+\r\n| ``max()`` | Returns maximal element in sequence | action |\r\n+-------------------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+------------------+\r\n| ``min()`` | Returns minimal element in sequence | action |\r\n+-------------------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+------------------+\r\n| ``max_by(func)`` | Returns element with maximal value ``func(element)`` | action |\r\n+-------------------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+------------------+\r\n| ``min_by(func)`` | Returns element with minimal value ``func(element)`` | action |\r\n+-------------------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+------------------+\r\n| ``sum()/sum(projection)`` | Returns the sum of elements possibly using a projection | action |\r\n+-------------------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+------------------+\r\n| ``product()/product(projection)`` | Returns the product of elements possibly using a projection | action |\r\n+-------------------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+------------------+\r\n| ``average()/average(projection)`` | Returns the average of elements possibly using a projection | action |\r\n+-------------------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+------------------+\r\n| ``aggregate(func)/aggregate(seed, func)/aggregate(seed, func, result_map)`` | Aggregate using ``func`` starting with ``seed`` or first element of list then apply ``result_map`` to the result | action |\r\n+-------------------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+------------------+\r\n| ``fold_left(zero_value, func)`` | Reduces element from left to right using ``func`` and initial value ``zero_value`` | action |\r\n+-------------------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+------------------+\r\n| ``fold_right(zero_value, func)`` | Reduces element from right to left using ``func`` and initial value ``zero_value`` | action |\r\n+-------------------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+------------------+\r\n| ``make_string(separator)`` | Returns string with ``separator`` between each ``str(element)`` | action |\r\n+-------------------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+------------------+\r\n| ``dict(default=None)`` / ``to_dict(default=None)`` | Converts a sequence of ``(Key, Value)`` pairs to a ``dictionary``. If ``default`` is not None, it must be a value or zero argument callable which will be used to create a ``collections.defaultdict`` | action |\r\n+-------------------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+------------------+\r\n| ``list()`` / ``to_list()`` | Converts sequence to a list | action |\r\n+-------------------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+------------------+\r\n| ``set() / to_set()`` | Converts sequence to a set | action |\r\n+-------------------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+------------------+\r\n| ``to_file(path)`` | Saves the sequence to a file at path with each element on a newline | action |\r\n+-------------------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+------------------+\r\n| ``to_csv(path)`` | Saves the sequence to a csv file at path with each element representing a row | action |\r\n+-------------------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+------------------+\r\n| ``to_jsonl(path)`` | Saves the sequence to a jsonl file with each element being transformed to json and printed to a new line | action |\r\n+-------------------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+------------------+\r\n| ``to_json(path)`` | Saves the sequence to a json file. The contents depend on if the json root is an array or dictionary | action |\r\n+-------------------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+------------------+\r\n| ``to_sqlite3(conn, tablename_or_query, *args, **kwargs)`` | Save the sequence to a SQLite3 db. The target table must be created in advance. | action |\r\n+-------------------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+------------------+\r\n| ``to_pandas(columns=None)`` | Converts the sequence to a pandas DataFrame | action |\r\n+-------------------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+------------------+\r\n| ``cache()`` | Forces evaluation of sequence immediately and caches the result | action |\r\n+-------------------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+------------------+\r\n| ``for_each(func)`` | Executes ``func`` on each element of the sequence | action |\r\n+-------------------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+------------------+\r\n\r\nLazy Execution\r\n~~~~~~~~~~~~~~\r\n\r\nWhenever possible, ``PyFunctional`` will compute lazily. This is accomplished by tracking the list of transformations that have been applied to the sequence and only evaluating them when an action is called. In ``PyFunctional`` this is called tracking lineage. This is also responsible for the\r\nability for ``PyFunctional`` to cache results of computation to prevent expensive re-computation. This is predominantly done to preserve sensible behavior and used sparingly. For example, calling ``size()`` will cache the underlying sequence. If this was not done and the input was an iterator, then\r\nfurther calls would operate on an expired iterator since it was used to compute the length. Similarly, ``repr`` also caches since it is most often used during interactive sessions where its undesirable to keep recomputing the same value. Below are some examples of inspecting lineage.\r\n\r\n.. code:: python\r\n\r\n def times_2(x):\r\n print(x)\r\n return 2 * x\r\n elements = seq(1, 1, 2, 3, 4).map(times_2).distinct()\r\n elements._lineage\r\n # Lineage: sequence -> map(times_2) -> distinct\r\n\r\n l_elements = elements.to_list()\r\n # Prints: 1\r\n # Prints: 1\r\n # Prints: 2\r\n # Prints: 3\r\n # Prints: 4\r\n\r\n elements._lineage\r\n # Lineage: sequence -> map(times_2) -> distinct -> cache\r\n\r\n l_elements = elements.to_list()\r\n # The cached result is returned so times_2 is not called and nothing is printed\r\n\r\nFiles are given special treatment if opened through the ``seq.open`` and related APIs. ``functional.util.ReusableFile`` implements a wrapper around the standard python file to support multiple iteration over a single file object while correctly handling iteration termination and file closing.\r\n\r\nRoad Map\r\n--------\r\n\r\n- Parallel execution engine for faster computation ``0.5.0``\r\n- SQL based query planner and interpreter (TBD on if/when/how this would be done)\r\n- When is this ready for ``1.0``?\r\n- Perhaps think of a better name that better suits this package than ``PyFunctional``\r\n\r\nContributing and Bug Fixes\r\n--------------------------\r\n\r\nAny contributions or bug reports are welcome. Thus far, there is a 100% acceptance rate for pull requests and contributors have offered valuable feedback and critique on code. It is great to hear from users of the package, especially what it is used for, what works well, and what could be improved.\r\n\r\nTo contribute, create a fork of ``PyFunctional``, make your changes, then make sure that they pass when running on `TravisCI `__ (you may need to sign up for an account and link Github). In order to be merged, all pull requests must:\r\n\r\n- Pass all the unit tests\r\n- Pass all the pylint tests, or ignore warnings with explanation of why its correct to do so\r\n- Must include tests that cover all new code paths\r\n- Must not decrease code coverage (currently at 100% and tested by `coveralls.io `__)\r\n- Edit the ``CHANGELOG.md`` file in the ``Next Release`` heading with changes\r\n\r\nContact\r\n-------\r\n\r\n`Google Groups mailing list `__\r\n\r\n`Gitter for chat `__\r\n\r\nSupported Python Versions\r\n-------------------------\r\n\r\n``PyFunctional`` supports and is tested against Python 2.7, 3.3, 3.4, 3.5, PyPy, and PyPy3\r\n\r\nChangelog\r\n---------\r\n\r\n`Changelog `__\r\n\r\nAbout me\r\n--------\r\n\r\nTo learn more about me (the author) visit my webpage at `pedrorodriguez.io `__.\r\n\r\nI am a PhD student in Computer Science at the University of Colorado at Boulder. My research interests include large-scale machine learning, distributed computing, and adjacent fields. I completed my undergraduate degree in Computer Science at UC Berkeley in 2015. I have previously done research in\r\nthe UC Berkeley AMPLab with Apache Spark, worked at Trulia as a data scientist, and developed several corporate and personal websites.\r\n\r\nI created ``PyFunctional`` while using Python extensively at Trulia, and finding that I missed the ease of use for manipulating data that Spark RDDs and Scala collections have. The project takes the best ideas from these APIs as well as LINQ to provide an easy way to manipulate data when using Scala\r\nis not an option or Spark is overkill.\r\n\r\nContributors\r\n------------\r\n\r\nThese people have generously contributed their time to improving ``PyFunctional``\r\n\r\n- `adrian17 `__\r\n- `lucidfrontier45 `__\r\n- `Digenis `__\r\n- `ChuyuHsu `__\r\n\r\n.. |TravisCI| image:: https://travis-ci.org/EntilZha/ScalaFunctional.svg?branch=master\r\n :target: https://travis-ci.org/EntilZha/ScalaFunctional\r\n.. |Coverage by codecov.io| image:: https://codecov.io/github/EntilZha/ScalaFunctional/coverage.svg?branch=master\r\n :target: https://codecov.io/github/EntilZha/ScalaFunctional?branch=master\r\n.. |ReadTheDocs| image:: https://readthedocs.org/projects/scalafunctional/badge/?version=latest\r\n :target: http://scalafunctional.readthedocs.org/en/\r\n.. |Latest Version| image:: https://badge.fury.io/py/scalafunctional.svg\r\n :target: https://pypi.python.org/pypi/scalafunctional/\r\n.. |Gitter| image:: https://badges.gitter.im/Join%20Chat.svg\r\n :target: https://gitter.im/EntilZha/ScalaFunctional?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge", "description_content_type": null, "docs_url": null, "download_url": "", "downloads": { "last_day": -1, "last_month": -1, "last_week": -1 }, "home_page": "https://github.com/EntilZha/ScalaFunctional", "keywords": "functional LINQ pipeline data collection rdd scala", "license": "MIT", "maintainer": "", "maintainer_email": "", "name": "ScalaFunctional", "package_url": "https://pypi.org/project/ScalaFunctional/", "platform": "UNKNOWN", "project_url": "https://pypi.org/project/ScalaFunctional/", "project_urls": { "Homepage": "https://github.com/EntilZha/ScalaFunctional" }, "release_url": "https://pypi.org/project/ScalaFunctional/0.6.0/", "requires_dist": [ "future", "six" ], "requires_python": null, "summary": "Package for creating data pipelines, LINQ, and chain functional programming", "version": "0.6.0" }, "last_serial": 2035039, "releases": { "0.0.0": [ { "comment_text": "", "digests": { "md5": "1767532de4f1b39b9f5e5ce06f56cf5c", "sha256": "ac3b91b1b7d65516458ee21b1b8f9c9d02115951c8c66f0524774e0eea2c68ba" }, "downloads": -1, "filename": "ScalaFunctional-0.0.0-py2-none-any.whl", "has_sig": false, "md5_digest": "1767532de4f1b39b9f5e5ce06f56cf5c", "packagetype": "bdist_wheel", "python_version": "py2", "requires_python": null, "size": 4726, "upload_time": "2015-02-05T20:51:21", "url": "https://files.pythonhosted.org/packages/d3/f9/3d189050d2eb44e7ab68f587064762894ebe72b579ced52b7a88cb085021/ScalaFunctional-0.0.0-py2-none-any.whl" }, { "comment_text": "", "digests": { "md5": "7eb53b190e065afcae23bbd857b4065c", "sha256": "1446b9d39097dac6b7888df50d7a007b44f811ac91e0403672fa570ce88daae4" }, "downloads": -1, "filename": "ScalaFunctional-0.0.0.tar.gz", "has_sig": false, "md5_digest": "7eb53b190e065afcae23bbd857b4065c", "packagetype": "sdist", "python_version": "source", "requires_python": null, "size": 2985, "upload_time": "2015-02-05T20:51:23", "url": "https://files.pythonhosted.org/packages/b1/cf/c23f9853092a23a3e5437849bf08fb48b719b9598a4d3095494ddc8bc931/ScalaFunctional-0.0.0.tar.gz" } ], "0.0.1": [ { "comment_text": "", "digests": { "md5": "4f643171c806a55003d7bfa8c4439bd3", "sha256": "18e599e428883938389c7706518cd85e5b396d2c5122d72aa58c4f7b44539df5" }, "downloads": -1, "filename": "ScalaFunctional-0.0.1-py2-none-any.whl", "has_sig": false, "md5_digest": "4f643171c806a55003d7bfa8c4439bd3", "packagetype": "bdist_wheel", "python_version": "py2", "requires_python": null, "size": 4731, "upload_time": "2015-02-05T21:30:24", "url": "https://files.pythonhosted.org/packages/6b/7b/cc92a059e3ed054d6323dd021606065b31c4e873755c53c8bf248be40d80/ScalaFunctional-0.0.1-py2-none-any.whl" }, { "comment_text": "", "digests": { "md5": "34d7c7d15f81b508e53931064c26c33a", "sha256": "22db0d6e8f82307a5197cfb5c07f6752d4fc686939a5a5d4f57a60a171f57a32" }, "downloads": -1, "filename": "ScalaFunctional-0.0.1.tar.gz", "has_sig": false, "md5_digest": "34d7c7d15f81b508e53931064c26c33a", "packagetype": "sdist", "python_version": "source", "requires_python": null, "size": 2994, "upload_time": "2015-02-05T21:30:26", "url": "https://files.pythonhosted.org/packages/69/b8/646b13dbc32467f3ece4c34846a2389829d252c0d9549086e2b03a7b1789/ScalaFunctional-0.0.1.tar.gz" } ], "0.0.2": [ { "comment_text": "", "digests": { "md5": "312f967ef1433895750d23b1e2e935cd", "sha256": "bffda88dcb40d5f91566119cdc29f6c0298e1f7de045fbaf79cf42a0f6a49780" }, "downloads": -1, "filename": "ScalaFunctional-0.0.2-py2-none-any.whl", "has_sig": false, "md5_digest": "312f967ef1433895750d23b1e2e935cd", "packagetype": "bdist_wheel", "python_version": "py2", "requires_python": null, "size": 4791, "upload_time": "2015-02-07T00:28:52", "url": "https://files.pythonhosted.org/packages/1e/31/590dc71feff4f0d3b8202889fcb012eb838ed98b0242f96d57809242b314/ScalaFunctional-0.0.2-py2-none-any.whl" }, { "comment_text": "", "digests": { "md5": "f2c706c16591a1e5bda5a3c8a6d7c37c", "sha256": "ca39cbe2fcdffd5344ec993c8649fa66287f63bd9e4e69c24db8c72a499d7afe" }, "downloads": -1, "filename": "ScalaFunctional-0.0.2.tar.gz", "has_sig": false, "md5_digest": "f2c706c16591a1e5bda5a3c8a6d7c37c", "packagetype": "sdist", "python_version": "source", "requires_python": null, "size": 3050, "upload_time": "2015-02-07T00:28:54", "url": "https://files.pythonhosted.org/packages/14/78/99b175851ebe00ca382cd29b0e5c085ffc39555a40d5cb369285f753ac66/ScalaFunctional-0.0.2.tar.gz" } ], "0.0.3": [ { "comment_text": "", "digests": { "md5": "cba0385ff12d8cf3ec038b6c7e53b7a1", "sha256": "47196834d1c92b2edb9b3225431304bbd4c3ed1c47c96e00b073b92d4225aead" }, "downloads": -1, "filename": "ScalaFunctional-0.0.3-cp27-none-macosx_10_10_x86_64.whl", "has_sig": false, "md5_digest": "cba0385ff12d8cf3ec038b6c7e53b7a1", "packagetype": "bdist_wheel", "python_version": "cp27", "requires_python": null, "size": 2111, "upload_time": "2015-02-10T17:07:21", "url": "https://files.pythonhosted.org/packages/53/b1/f278e768a833461df833e2bc67c581b182002df1aaf028d3694c8d21b852/ScalaFunctional-0.0.3-cp27-none-macosx_10_10_x86_64.whl" }, { "comment_text": "", "digests": { "md5": "cc96c761653392663b60ade57a471a48", "sha256": "9ff501213205e5a7380de99a571fbaab3a4d9e8767952f53f4de6e2e1e712f25" }, "downloads": -1, "filename": "ScalaFunctional-0.0.3.tar.gz", "has_sig": false, "md5_digest": "cc96c761653392663b60ade57a471a48", "packagetype": "sdist", "python_version": "source", "requires_python": null, "size": 2029, "upload_time": "2015-02-10T17:07:23", "url": "https://files.pythonhosted.org/packages/9c/36/8fa5087ca4a0309f8be1c7f6260fbf7203bc77f0a3fe2c1837bc863b75da/ScalaFunctional-0.0.3.tar.gz" } ], "0.1.0": [ { "comment_text": "", "digests": { "md5": "e19c81dfabfc4389ba5733c9b1d95938", "sha256": "d21b0a1f400ce5d68e8d401314548f004bca67b999060ffd723affe54cff10c2" }, "downloads": -1, "filename": "ScalaFunctional-0.1.0-py2-none-any.whl", "has_sig": false, "md5_digest": "e19c81dfabfc4389ba5733c9b1d95938", "packagetype": "bdist_wheel", "python_version": "py2", "requires_python": null, "size": 4962, "upload_time": "2015-03-09T20:54:12", "url": "https://files.pythonhosted.org/packages/29/f2/d5741a282ba0e811c8a2d507ecde4c7f7530e5ee6424ee7aafd5f0a9894e/ScalaFunctional-0.1.0-py2-none-any.whl" }, { "comment_text": "", "digests": { "md5": "26c83f99eb183611b030ffd7bd1b4576", "sha256": "013c4dbcc5127405b935aa478df983d84ea130c82906caf5cc556a9526fd5941" }, "downloads": -1, "filename": "ScalaFunctional-0.1.0.tar.gz", "has_sig": false, "md5_digest": "26c83f99eb183611b030ffd7bd1b4576", "packagetype": "sdist", "python_version": "source", "requires_python": null, "size": 3280, "upload_time": "2015-03-09T20:54:15", "url": "https://files.pythonhosted.org/packages/a8/13/cbbba99e1df377fcd073d8d67a1c7bc954453b25b4e4a33ca808e62eda97/ScalaFunctional-0.1.0.tar.gz" } ], "0.1.1": [ { "comment_text": "", "digests": { "md5": "ad2aac6cc49cae48ddd0d9c318bd7838", "sha256": "1328181b93983760277725208505716a866f06fd7ace5b1bdea8920c6291eb5e" }, "downloads": -1, "filename": "ScalaFunctional-0.1.1-py2-none-any.whl", "has_sig": false, "md5_digest": "ad2aac6cc49cae48ddd0d9c318bd7838", "packagetype": "bdist_wheel", "python_version": "py2", "requires_python": null, "size": 5003, "upload_time": "2015-03-10T01:08:32", "url": "https://files.pythonhosted.org/packages/ad/f6/8f179a3406cd1bc88965f9fac1beb8c0ff7cf31fb6b53ae4dd30793bee57/ScalaFunctional-0.1.1-py2-none-any.whl" } ], "0.1.2": [ { "comment_text": "", "digests": { "md5": "d5b277c40416d87b297592d307df0e55", "sha256": "e7ea7be78254267913763d2b48e9d2fcd9d47cb2c9f3e39d2e87ef2c696cd81a" }, "downloads": -1, "filename": "ScalaFunctional-0.1.2-py2-none-any.whl", "has_sig": false, "md5_digest": "d5b277c40416d87b297592d307df0e55", "packagetype": "bdist_wheel", "python_version": "py2", "requires_python": null, "size": 5012, "upload_time": "2015-03-10T01:52:06", "url": "https://files.pythonhosted.org/packages/5e/59/a3f2b5a5bd5b94030c3a0ea0ad31882e51a04c3dc4cb0e9ff58dc0355f6c/ScalaFunctional-0.1.2-py2-none-any.whl" } ], "0.1.3": [ { "comment_text": "", "digests": { "md5": "bc088a7a352e6c93b06b48ace7aef468", "sha256": "b5a83322bb2a0abf6e46fec0422b607848fbd20dc8aa95db5d36c5e0e71bf8e5" }, "downloads": -1, "filename": "ScalaFunctional-0.1.3-py2-none-any.whl", "has_sig": false, "md5_digest": "bc088a7a352e6c93b06b48ace7aef468", "packagetype": "bdist_wheel", "python_version": "py2", "requires_python": null, "size": 5046, "upload_time": "2015-03-10T02:16:03", "url": "https://files.pythonhosted.org/packages/ca/ac/5f6793d5114cd222e7f108285b2e4f206b124d0f82c0a2c82559949b1b0b/ScalaFunctional-0.1.3-py2-none-any.whl" } ], "0.1.4": [ { "comment_text": "", "digests": { "md5": "9e2d75d7b45528b51f903aed7d3dce22", "sha256": "ba1d3b83de90c6ccf2c8d18409de69ce098d7b073cc90cd55dc9486e1f043a15" }, "downloads": -1, "filename": "ScalaFunctional-0.1.4-py2.py3-none-any.whl", "has_sig": false, "md5_digest": "9e2d75d7b45528b51f903aed7d3dce22", "packagetype": "bdist_wheel", "python_version": "py2.py3", "requires_python": null, "size": 3651, "upload_time": "2015-03-10T12:11:06", "url": "https://files.pythonhosted.org/packages/b1/f9/c36ede897e50163f7e0d0fd70c93169e63114ccbdc9f2b071610d5a9e4ce/ScalaFunctional-0.1.4-py2.py3-none-any.whl" } ], "0.1.5": [ { "comment_text": "", "digests": { "md5": "9557edac87fbe19e46af347a4ec4b077", "sha256": "e30693ab2ba729547883a15aa221c29b7fbd9da39825f7dae3fcd4a262c33b9f" }, "downloads": -1, "filename": "ScalaFunctional-0.1.5-py2.py3-none-any.whl", "has_sig": false, "md5_digest": "9557edac87fbe19e46af347a4ec4b077", "packagetype": "bdist_wheel", "python_version": "py2.py3", "requires_python": null, "size": 3679, "upload_time": "2015-03-10T13:23:51", "url": "https://files.pythonhosted.org/packages/9e/e4/860e07c77007eea9d2105dcecdbdb70b1ed33eec1ae48b419bc9dab2bfcd/ScalaFunctional-0.1.5-py2.py3-none-any.whl" }, { "comment_text": "", "digests": { "md5": "d5a1e3b34d87a3beaa93c51c2d4f3afd", "sha256": "ca484f59043b679b0df2b14f17590ae963c64f5ee32c5ec76513764e80aefd15" }, "downloads": -1, "filename": "ScalaFunctional-0.1.5.tar.gz", "has_sig": false, "md5_digest": "d5a1e3b34d87a3beaa93c51c2d4f3afd", "packagetype": "sdist", "python_version": "source", "requires_python": null, "size": 3478, "upload_time": "2015-03-10T13:23:54", "url": "https://files.pythonhosted.org/packages/a0/a3/702a011f4e7e14782745c078bd67b2eae6f5c190705b407c07032a1231f2/ScalaFunctional-0.1.5.tar.gz" } ], "0.1.6": [ { "comment_text": "", "digests": { "md5": "9978b942e0daab15ea7ae3a4abe32b49", "sha256": "b774099af3e1602429b1fda48b559386cf4df992aeb1772df54ed53a08495dd2" }, "downloads": -1, "filename": "ScalaFunctional-0.1.6-py2.py3-none-any.whl", "has_sig": false, "md5_digest": "9978b942e0daab15ea7ae3a4abe32b49", "packagetype": "bdist_wheel", "python_version": "py2.py3", "requires_python": null, "size": 4977, "upload_time": "2015-03-12T05:17:23", "url": "https://files.pythonhosted.org/packages/35/e0/4a4d887077ae6b5a0fe73d7a2cf4d47fc6e4bb2b4b7869f33e3d4e3442ec/ScalaFunctional-0.1.6-py2.py3-none-any.whl" }, { "comment_text": "", "digests": { "md5": "9f1bda61ca9a9b2cdfb09397e77926f7", "sha256": "7be930a712db8e4730191a710bc435c925403a1e91ddb94ceb9024c7c14e6fe3" }, "downloads": -1, "filename": "ScalaFunctional-0.1.6.tar.gz", "has_sig": false, "md5_digest": "9f1bda61ca9a9b2cdfb09397e77926f7", "packagetype": "sdist", "python_version": "source", "requires_python": null, "size": 5630, "upload_time": "2015-03-12T05:17:26", "url": "https://files.pythonhosted.org/packages/d7/09/ad9ba77bd0aec3d7045bac5a33cda05ddfd04bd7c36d8651a7d8f878ea58/ScalaFunctional-0.1.6.tar.gz" } ], "0.2.0": [ { "comment_text": "", "digests": { "md5": "c9182a870f8d974cc3a9ef2a1cca0d56", "sha256": "77d0a65e542cc9b3dae62a83fc50644da0b4b4870aa39e9ce25459eebbe625ff" }, "downloads": -1, "filename": "ScalaFunctional-0.2.0-py2.py3-none-any.whl", "has_sig": false, "md5_digest": "c9182a870f8d974cc3a9ef2a1cca0d56", "packagetype": "bdist_wheel", "python_version": "py2.py3", "requires_python": null, "size": 9305, "upload_time": "2015-03-23T02:33:22", "url": "https://files.pythonhosted.org/packages/b3/dd/e0ada4aa656c381b16e68841000256dbf31fa6e2cd42408e7a806e30c627/ScalaFunctional-0.2.0-py2.py3-none-any.whl" }, { "comment_text": "", "digests": { "md5": "6d63d4d82db3d07234f9d0ff4c9464c6", "sha256": "16d31a5e35845978b6ed6fcc625c1f3a22627beb7278fb0d94ec0ad1090f7b5b" }, "downloads": -1, "filename": "ScalaFunctional-0.2.0.tar.gz", "has_sig": false, "md5_digest": "6d63d4d82db3d07234f9d0ff4c9464c6", "packagetype": "sdist", "python_version": "source", "requires_python": null, "size": 10599, "upload_time": "2015-03-23T02:33:25", "url": "https://files.pythonhosted.org/packages/e1/9b/55d662a51ac74591ec7c461f83c3215a139fbfca9abac232039a5dcb2429/ScalaFunctional-0.2.0.tar.gz" } ], "0.3.0": [ { "comment_text": "", "digests": { "md5": "9723ca4226aadf3f2537d7e4f4c8097f", "sha256": "97822fe5e35da71f9067161d78d16b16b979a80114ce9e1597e6cf15336e0ede" }, "downloads": -1, "filename": "ScalaFunctional-0.3.0-py2.py3-none-any.whl", "has_sig": false, "md5_digest": "9723ca4226aadf3f2537d7e4f4c8097f", "packagetype": "bdist_wheel", "python_version": "py2.py3", "requires_python": null, "size": 12588, "upload_time": "2015-06-09T22:04:12", "url": "https://files.pythonhosted.org/packages/dc/0f/9338319e9f227c6951865edb86f3141c2308962dba4b6f93fe3ab8a98e0e/ScalaFunctional-0.3.0-py2.py3-none-any.whl" }, { "comment_text": "", "digests": { "md5": "4884a7f92af35cf4cb87785c7e552a97", "sha256": "edd37efcd59aca9c1575138faf4c26628b3012c796b84afe56c861a3b64c15ef" }, "downloads": -1, "filename": "ScalaFunctional-0.3.0.tar.gz", "has_sig": false, "md5_digest": "4884a7f92af35cf4cb87785c7e552a97", "packagetype": "sdist", "python_version": "source", "requires_python": null, "size": 13245, "upload_time": "2015-06-09T22:04:16", "url": "https://files.pythonhosted.org/packages/6a/7f/45334e30edef063249948cfabd40229ae2edc87f1476ccd8661ffb12cdd7/ScalaFunctional-0.3.0.tar.gz" }, { "comment_text": "", "digests": { "md5": "f2e72bd463e7faebb1a08a1f57c15af6", "sha256": "130d65e125ee4222ae7dc104d70f2964d08d98a92238bc42edf7732bbcceb11f" }, "downloads": -1, "filename": "ScalaFunctional-0.3.0.zip", "has_sig": false, "md5_digest": "f2e72bd463e7faebb1a08a1f57c15af6", "packagetype": "sdist", "python_version": "source", "requires_python": null, "size": 16491, "upload_time": "2015-06-09T22:51:19", "url": "https://files.pythonhosted.org/packages/8c/bf/150539f87e548f1c170ec56f08e72028fc89d03d9fb990c1b02bb0a8ae35/ScalaFunctional-0.3.0.zip" } ], "0.3.1": [ { "comment_text": "", "digests": { "md5": "0f392e429a476c6189ab07eb1a76ec1a", "sha256": "82f25d1472e242123d4863f271155c6dba98dfdc3d39ec026206e76ec19ac548" }, "downloads": -1, "filename": "ScalaFunctional-0.3.1-py2.py3-none-any.whl", "has_sig": false, "md5_digest": "0f392e429a476c6189ab07eb1a76ec1a", "packagetype": "bdist_wheel", "python_version": "py2.py3", "requires_python": null, "size": 12750, "upload_time": "2015-07-22T23:16:22", "url": "https://files.pythonhosted.org/packages/95/3a/fe2a52d8faad2efe21d60a421d7b44b7fdae363db0defddd2233ae350fce/ScalaFunctional-0.3.1-py2.py3-none-any.whl" }, { "comment_text": "", "digests": { "md5": "7213a9aca45f18b3605b2175f3857355", "sha256": "d471115195960c86b0c53755affc134ab20f10f3ed7bb912850c2f813c56fdf3" }, "downloads": -1, "filename": "ScalaFunctional-0.3.1.tar.gz", "has_sig": false, "md5_digest": "7213a9aca45f18b3605b2175f3857355", "packagetype": "sdist", "python_version": "source", "requires_python": null, "size": 13497, "upload_time": "2015-07-22T23:16:26", "url": "https://files.pythonhosted.org/packages/14/6a/9dfeccd39e6c49220ef460f5f978c691ccf4d0cc4617bba898f4b8469980/ScalaFunctional-0.3.1.tar.gz" } ], "0.4.0": [ { "comment_text": "", "digests": { "md5": "6153cf05e15df563e3a385d98a5e49ec", "sha256": "afc98b55ca75af851d5d7101cd5dc368ccc1748a6e46d3f71e47d222459c0b81" }, "downloads": -1, "filename": "ScalaFunctional-0.4.0-py2.py3-none-any.whl", "has_sig": false, "md5_digest": "6153cf05e15df563e3a385d98a5e49ec", "packagetype": "bdist_wheel", "python_version": "py2.py3", "requires_python": null, "size": 39826, "upload_time": "2015-11-04T02:45:03", "url": "https://files.pythonhosted.org/packages/98/b7/dc4457f10aaf92446ceb349c731a8b03cf135bb3f4b780a44fe2dbc0f8b0/ScalaFunctional-0.4.0-py2.py3-none-any.whl" }, { "comment_text": "", "digests": { "md5": "6d97d9be97e8ab95d8692b778665e799", "sha256": "441e97e7158fe1e6c41ccb3d9a7d624df158d9c5f7c8b917968784671421f773" }, "downloads": -1, "filename": "ScalaFunctional-0.4.0.tar.gz", "has_sig": false, "md5_digest": "6d97d9be97e8ab95d8692b778665e799", "packagetype": "sdist", "python_version": "source", "requires_python": null, "size": 47241, "upload_time": "2015-11-04T02:45:13", "url": "https://files.pythonhosted.org/packages/70/07/b3a7f42896f98375f64511b7f73784d4b5139a02afa86d26fa9718a24aa0/ScalaFunctional-0.4.0.tar.gz" } ], "0.4.1": [ { "comment_text": "", "digests": { "md5": "18f5d3a9f3d9346789c4122d238fc53c", "sha256": "aba33b3b9f01b231b654497a7f4a3f16bfcfd3ae5b242f088f686c41d70f46c3" }, "downloads": -1, "filename": "ScalaFunctional-0.4.1-py2.py3-none-any.whl", "has_sig": false, "md5_digest": "18f5d3a9f3d9346789c4122d238fc53c", "packagetype": "bdist_wheel", "python_version": "py2.py3", "requires_python": null, "size": 39812, "upload_time": "2015-11-04T03:40:43", "url": "https://files.pythonhosted.org/packages/11/b2/3e9449c3af93ff6f7d3f091e8cce892837b3fad4d77881ccbea6a2fc3fc9/ScalaFunctional-0.4.1-py2.py3-none-any.whl" }, { "comment_text": "", "digests": { "md5": "466e5f2ea984daf7724f777a3f093b23", "sha256": "f286dc67f3533d4ef83ab4fae43e9ee3305097958f174591be2ebedf3474ec08" }, "downloads": -1, "filename": "ScalaFunctional-0.4.1.tar.gz", "has_sig": false, "md5_digest": "466e5f2ea984daf7724f777a3f093b23", "packagetype": "sdist", "python_version": "source", "requires_python": null, "size": 47201, "upload_time": "2015-11-04T03:40:50", "url": "https://files.pythonhosted.org/packages/c8/ac/182d6e21ad6f5592c243bbc9c9f4739ac287dfb9374c8c0ddb13e233701b/ScalaFunctional-0.4.1.tar.gz" } ], "0.5.0": [ { "comment_text": "", "digests": { "md5": "d81da889333249626e19ff35484efedf", "sha256": "c773a9aac7a5d6f95bf36ce3a02337e26b104f3cb04b233d06dce1e2904ed552" }, "downloads": -1, "filename": "ScalaFunctional-0.5.0-py2.py3-none-any.whl", "has_sig": false, "md5_digest": "d81da889333249626e19ff35484efedf", "packagetype": "bdist_wheel", "python_version": "py2.py3", "requires_python": null, "size": 40701, "upload_time": "2016-01-01T02:12:24", "url": "https://files.pythonhosted.org/packages/ec/8b/53100bd87d719341669d83dbe286c465b24dc7aac806a038cec66363a783/ScalaFunctional-0.5.0-py2.py3-none-any.whl" }, { "comment_text": "", "digests": { "md5": "371bd677ff17a24328c689645f12a073", "sha256": "1fadc46748cb92596d2023f7c83362656ba41ec96993c3835a9b48321fa23135" }, "downloads": -1, "filename": "ScalaFunctional-0.5.0.tar.gz", "has_sig": false, "md5_digest": "371bd677ff17a24328c689645f12a073", "packagetype": "sdist", "python_version": "source", "requires_python": null, "size": 48330, "upload_time": "2016-01-01T02:12:30", "url": "https://files.pythonhosted.org/packages/5f/ac/743c76802a329414ad1f57e15535834abc4ee1eb6c73c01a7791da908cd4/ScalaFunctional-0.5.0.tar.gz" } ], "0.6.0": [ { "comment_text": "", "digests": { "md5": "a66b457ff5d6e9a5d782a52793286034", "sha256": "69da08c64d2b57ca7f5a8e7803ed67c1aa7fcb2a3edb30954656be9ae0ad8085" }, "downloads": -1, "filename": "ScalaFunctional-0.6.0-py2.py3-none-any.whl", "has_sig": false, "md5_digest": "a66b457ff5d6e9a5d782a52793286034", "packagetype": "bdist_wheel", "python_version": "py2.py3", "requires_python": null, "size": 44829, "upload_time": "2016-03-30T00:01:35", "url": "https://files.pythonhosted.org/packages/36/d9/cde202bf6d2e5e1589dfee08196b3dbdec640299432ba1f3d08d07cbd3c2/ScalaFunctional-0.6.0-py2.py3-none-any.whl" }, { "comment_text": "", "digests": { "md5": "3e48b74924deef87ca9d9b947b83a0ff", "sha256": "5745c818524684f9f67b7e7ababe0fdcaf499f1f559833e6284dfaa4ea244fc4" }, "downloads": -1, "filename": "ScalaFunctional-0.6.0.tar.gz", "has_sig": false, "md5_digest": "3e48b74924deef87ca9d9b947b83a0ff", "packagetype": "sdist", "python_version": "source", "requires_python": null, "size": 52775, "upload_time": "2016-03-30T00:01:41", "url": "https://files.pythonhosted.org/packages/32/3c/f52d36b32997615294efa100fe0411a5a76508159121944d4d10579a2a16/ScalaFunctional-0.6.0.tar.gz" } ] }, "urls": [ { "comment_text": "", "digests": { "md5": "a66b457ff5d6e9a5d782a52793286034", "sha256": "69da08c64d2b57ca7f5a8e7803ed67c1aa7fcb2a3edb30954656be9ae0ad8085" }, "downloads": -1, "filename": "ScalaFunctional-0.6.0-py2.py3-none-any.whl", "has_sig": false, "md5_digest": "a66b457ff5d6e9a5d782a52793286034", "packagetype": "bdist_wheel", "python_version": "py2.py3", "requires_python": null, "size": 44829, "upload_time": "2016-03-30T00:01:35", "url": "https://files.pythonhosted.org/packages/36/d9/cde202bf6d2e5e1589dfee08196b3dbdec640299432ba1f3d08d07cbd3c2/ScalaFunctional-0.6.0-py2.py3-none-any.whl" }, { "comment_text": "", "digests": { "md5": "3e48b74924deef87ca9d9b947b83a0ff", "sha256": "5745c818524684f9f67b7e7ababe0fdcaf499f1f559833e6284dfaa4ea244fc4" }, "downloads": -1, "filename": "ScalaFunctional-0.6.0.tar.gz", "has_sig": false, "md5_digest": "3e48b74924deef87ca9d9b947b83a0ff", "packagetype": "sdist", "python_version": "source", "requires_python": null, "size": 52775, "upload_time": "2016-03-30T00:01:41", "url": "https://files.pythonhosted.org/packages/32/3c/f52d36b32997615294efa100fe0411a5a76508159121944d4d10579a2a16/ScalaFunctional-0.6.0.tar.gz" } ] }