semvec/pypi-packages huggingface dataset:
dslibs-baosws 0.0.1
A unified module of frequently used data-science modules
Requires Python: >=3.6

Find yourself doing these over and over again everytime you start a new project or notebook?
```
pip3 install pandas scikit-learn matplotlib numpy statmodels scipy seaborn ...
```
and
```
import numpy as np
import pandas as pd
import seaborn as sns
import matplotlib.pyplot as plt
import scipy
...
```

**dslibs** eases your pain with an *unified module* that automatically installs and imports frequently used data science modules like numpy, pandas, scikit-learn, etc. in just a sec.

# Installation
```
pip install dslibs-baosws
```

# Usage
Just `from dslibs import *`:
```
>>> from dslibs import *
-------------------------------------------------------
Following modules was installed and imported by dslibs:
"numpy" as "np"
"pandas" as "pd"
"sklearn" as "skl"
"sklearn.preprocessing" as "spp"
"sklearn.model_selection" as "sms"
"sklearn.pipeline" as "spl"
"sklearn.metrics" as "smt"
"sklearn.feature_selection" as "sfs"
"matplotlib.pyplot" as "plt"
"statsmodels.api" as "sma"
"scipy" as "sp"
-------------------------------------------------------
>>>  # now we can use 'pd' without 'import pandas as pd' as usual
>>> df = pd.DataFrame({'A': [1, 2, 3], 'B': [4, 5, 6]})
>>> df
A  B
0  1  4
1  2  5
2  3  6
```

# Currently supported imports
| module                    | alias |
|---------------------------|-------|
| numpy                     | np    |
| pandas                    | pd    |
| sklearn                   | skl   |
| sklearn.preprocessing     | spp   |
| sklearn.model_selection   | sms   |
| sklearn.pipeline          | spl   |
| sklearn.metrics           | smt   |
| sklearn.feature_selection | sfs   |
| matplotlib.pyplot         | plt   |
| statsmodels.api           | sma   |
| scipy                     | sp    |
| seaborn                   | sns   |
wallet-lib 1.2.7
Package to work with hot wallet for different cryptocurrency
Requires Python: >=3.6

# Wallet lib
[![PyPI version](https://badge.fury.io/py/wallet-lib.svg)](https://badge.fury.io/py/wallet-lib) ![](https://github.com/Bitcoin-com/wallet_lib/workflows/CI/badge.svg)
## Description
This library contains classes to work with hot wallet for different cryptocurrency.
## API Documentation
### Supported cryptocurrencies
1. BCH
1. BTC
1. DASH
1. ZEC
### Methods
1. `wallet.create_address(label=None)` - creates an address (label is ignored for ZEC)
1. `wallet.get_balance()` - returns the current balance
1. `wallet.get_transaction(tx_id)` - returns transaction info by tx id
1. `wallet.get_transactions(label=None, count=25, offset=0)` - returns list of transactions by label based on count and offset arguments.
1. `wallet.send(address, amount)` - sends some amount to an address.
1. `wallet.get_transactions_since(blockhash=None, target_confirmations=1)` - gets all transactions since block: blockhash, or all transactions if blockhash is None. target_confirmations return the nth from the best blockhash.
1. `wallet.run(command, *args)` - runs a custom command with the arguments specified
1. `wallet.get_zmq_notifier(zmq_address, topics=[{ALL_TOPICS}], loop=None, verbose=False)` - API for receiving topics from specified zmq address (ipc, tpc and udp supported).
keyboard-listener 0.0.7
A keyboard listener that allows for custom combinations and keywords to trigger custom functions
Requires Python: >=3.6

# keyboard_listener

Keyboard Listener is a module that allows you to create custom hotkeys (combinations) or custom keywords and bind them to custom functions in Python. It's really easy to use and can be installed via pip:

`pip install keyboard_listener`

**Combinations** are custom hotkeys that are bound to functions. When the combination is pressed, the function is executed. Combos are really easy to set up and can be seen in the example below.

**Keywords** are custom strings that when entered (or rather, when their characters are entered in sequence) trigger a function to be executed. Keywords are also shown in the example below.

**KeyboardListener** object needs to be instantiated with the custom combinations and custom keywords dictionaries before running. Please refer to the below example to see how to set those up. If no dictionaries are passed, the program will assume no combinations or keywords are set up.

## Example:

```python
from keyboard_listener import KeyboardListener, Combo, KeyWord

def function_1(arguments):
  # do something

def function_2(arguments):
  # do something else

combinations = {

      'function 1': Combo(['alt'], 'f', function_1, arguments), 
        #Function 1 is executed when the user presses Alt+F
      'function 2': Combo(['ctr','alt'], 'g', function_2, arguments), 
        #Function 2 is executed when the user presses Alt+G
      'function 3': Combo(['shift','alt'], 'H', function_2, arguments), 
        #Be mindful when setting up Combos that include 'shift'. If the Combo includes the shift key, the character must be uppercase.
}

keywords = {

    'keyword_1': KeyWord('keyword1', function_1, arguments), 
      #Function 1 is executed when the user types 'keyword1'
    'keyword_2': KeyWord('keyword1', function_2, arguments) 
      #Function 2 is executed when the user types 'keyword2'
}

keyboard_listener = KeyboardListener(combinations=combinations, keywords=keywords)
keyboard_listener.run()
```
EnsemblePursuit 0.0.3
A sparse matrix factorization algorithm for extracting co-activating neurons from large-scale recordings
Requires Python: >=3.6

# EnsemblePursuit-- a sparse matrix factorization algorithm for extracting co-activating neurons from large-scale recordings

Ensemble Pursuit is a matrix factorization algorithm that extracts sparse neural components of co-activating cells. 

<img src="https://github.com/mariakesa/EnsemblePursuit/blob/master/Figures/fig11.png" height="150" width="350">

The matrix U is a sparse matrix (because of an L0 penalty in the cost function) that encodes which neurons belong to a component. V is an average timecourse of these neurons, e.g. component time course.

For more details see the  [wiki](https://github.com/mariakesa/EnsemblePursuit/wiki) and our [Statistical Analysis of Neural Data 2019 workshop poster](https://github.com/mariakesa/EnsemblePursuit/blob/master/sand_poster2019.pdf)

![Alt Text](https://github.com/MouseLand/EnsemblePursuit/blob/master/Figures/my_gif.gif)

Ensembles learned using EnsemblePursuit from recordings in V1 have Gabor receptive fields. 

![alt text](https://github.com/mariakesa/EnsemblePursuit/blob/master/Figures/ep_rec_fields.png)

Some ensembles are well explained by behavior PC's extracted from mouse orofacial movies.

![](https://github.com/mariakesa/EnsemblePursuit/blob/master/Figures/mouse.gif)


![alt text](https://github.com/mariakesa/EnsemblePursuit/blob/master/Figures/Behavior.png)