semvec/pypi-packages huggingface dataset:
mapjoin 0.2.0
the OBSCENE string generation one-liner
Requires Python: >=3
Keywords: automation cli

mapjoin: the OBSCENE string generation one-liner
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

The purpose of the mapjoin function is to have an alternative to str.join that
looks more like os.path.join (which takes ``*args``).

``mapjoin()``
=============

.. code-block:: python

   from mapjoin import mapjoin, strjoin

   mapjoin('foo', 2)                      # raise TypeError
   mapjoin('foo', 2, sep='_', key=str)    # return 'foo_2'

   # you can also make mapjoin use your own callback with the key kwarg:
   your_formatter = lambda key: str(key) if key else 'Nothin!'
   mapjoin('foo', obj, 2, None, sep='\n', key=your_formatter)

``strjoin()``
=============

.. code-block:: python

   strjoin('foo', 2)                      # 'foo-2'
   strjoin('foo', 2, sep='_')             # 'foo_2'


But ... why ?
=============

Initially, because I make to many mistakes when I write an os.path.join call and then a
str.join call in a row:

.. code-block:: python

   >>> os.path.join('a', 'b')
   'a/b'

   # and 2 seconds later i'm doing this:

   >>> ' '.join('a', 'b')
   TypeError: join() takes exactly one argument (2 given)

   # and instead of "just fixit and move on", i decided try to make a joint

But also because I can't get no satisfaction with my code when it looks like:

.. code-block:: python

   readable = ' '.join(map(str, [
       'hello',
       f'__{name}__',
       something,
   ]))

   # or:

   def foo():
       readable = textwrap.dedent(f'''
       hello
       __{name}__
       ''').strip()

`Participate to the story
<https://mail.python.org/pipermail/python-ideas/2019-January/054995.html>`_
sparklanes 0.2.4
A lightweight framework to build and execute data processing pipelines in pyspark (Apache Spark's python API)
Requires Python: >=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, <4
Keywords: spark,pyspark,data,processing,preprocessing,pipelines

sparklanes is a lightweight data processing framework for Apache Sparkwritten in Python. It was built with the intention to make buildingcomplex spark processing pipelines simpler, by shifting the focustowards writing data processing code without having to spent much timeon the surrounding application architecture.
Data processing pipelines, or *lanes*, are built by stringing togetherencapsulated processor classes, which allows creation of lane definitionswith an arbitrary processor order, where processors can be easilyremoved, added or swapped.
Processing pipelines can be defined using *lane configuration YAML files*,to then be packaged and submitted to spark using a single command.Alternatively, the same can be achieved manually by using the frameworkAPI.
tdcca 0.0.0
Time-dependent Canonical Correlation Analysis

# Time-dependent Canonical Correlation Analysis 
Canonical Correlation Analysis is a technique in multivariate data analysis for finding correlation and pairs of vectors that maximizes the correlation between a set of paired variables. Many important problems involve recoding time-dependent observations. In order to understand the coupling dynamics between the two sources, spot trends, detect anomalies, in this paper, we introduce the time-dependent canonical correlation analysis (TDCCA), a method of inferring time-dependent canonical vectors of paired variables.  


## Getting Started
We provide both simulation examples used in our paper. The main computation algorithm is not added into the class method for the convenience of algorithm development for multi-view data. The package saves all the analysis to the given folder and saves the preprocessed data into the hdf5 file. The parallel computing with multi-cores is also allowed and tested in Linux system. This package also provides other algorithms to optimize the function, including cvxpy naive optimization, cvxpy naive admm optimization and two other admm algorithms. For details, see the admm_computation.py file. However, these functions have not been tested thoroughly. 

These instructions will get you a copy of the project up running on your local machine for development and testing purposes. 

This package is also published in pypi. For a quick installation, try

```
pip install tdcca 
```

### Prerequisites

What things you need to install the software and how to install them

```
See setup.py for details of packages requirements. 
```

### Installing from GitHub


Download the packages by using git clone https://github.com/xuefeicao/tdcca.git

```
python setup.py install
```

If you experience problems related to installing the dependency Matplotlib on OSX, please see https://matplotlib.org/faq/osx_framework.html 

### Intro to our package
After installing our package locally, try to import tdcca in your python environment and learn about package's function. 
Note: our package name in pypi is tdcca. It is recommended that users scale the data before running our package. 
```
from tdcca import *
help(multi_sim)
```


### Examples
```
The examples subfolder includes simulations provided in the paper. 
```

## Running the tests

The test has been conducted in both Linux and Mac Os. 

## Built With

* Python 2.7

## Compatibility
* Python 2.7


## Authors

* **Xuefei Cao** - *Maintainer* - (https://github.com/xuefeicao)
* **Jun Ke**
* **Xi Luo** (http://bigcomplexdata.com/)
* **Björn Sandstede** (http://www.dam.brown.edu/people/sandsted/)


## License

This project is licensed under the MIT License - see the LICENSE file for details