semvec/pypi-packages huggingface dataset:
streamlit-sanddance 0.0.7
Streamlit component that allows you to view a SandDance visualization of a dataframe.
Requires Python: >=3.7

# streamlit-sanddance

Streamlit component that allows you to view a SandDance visualization of a dataframe.

## Installation instructions

```sh
pip install streamlit-sanddance
```

## Usage instructions

```python
import streamlit as st

from streamlit_sanddance import sanddance

#sample random DataFrame
df = pd.DataFrame(
     np.random.randn(20, 3),
     columns=['a', 'b', 'c'])

#make sure to use a key to prevent refreshing after an event
sdEvent = sanddance(df, key='sd1')

#if sdEvent is not None and contains a cubeClick >= 0, display the data row
if sdEvent is not None and 'cubeClick' in sdEvent and sdEvent['cubeClick'] is not None and sdEvent['cubeClick'] >= 0:
        st.write(df.iloc[sdEvent['cubeClick']])
else:
        st.write("No cubeClick event")

```
The return value is a dictionary of visual interaction events such as selections. 

## Dev Setup

* Ensure you have [Python 3.6+](https://www.python.org/downloads/).
* Create a new Python virtual environment for the Streamlit component:
```
$ cd streamlit
$ python3 -m venv venv  # create venv
$ . venv/bin/activate   # activate venv
$ pip install streamlit # install streamlit
```
* Initialize and run the component frontend:
```
$ cd streamlit/sanddance/frontend
$ npm install    # Install npm dependencies
$ npm run start  # Start the Webpack dev server
```
* From a separate terminal, run the Streamlit app:
```
$ cd streamlit
$ . venv/bin/activate  # activate the venv you created earlier
$ pip install -e . # install streamlit-sanddance as editable package
$ streamlit run sanddance/example.py  # run the example
```
fpfs 3.1.1
FPFS shear estimator
Requires Python: >=3.8

# `FPFS`: Fourier Power Function Shaplets (A fast, accurate shear estimator)
----
[![docs](https://readthedocs.org/projects/fpfs/badge/?version=latest)](https://fpfs.readthedocs.io/en/latest/?badge=latest)
[![tests](https://github.com/mr-superonion/FPFS/actions/workflows/tests.yml/badge.svg?branch=master)](https://github.com/mr-superonion/FPFS/actions/workflows/tests.yml)
[![pypi](https://github.com/mr-superonion/FPFS/actions/workflows/pypi.yml/badge.svg)](https://pypi.org/project/fpfs/)
[![License: GPL v3](https://img.shields.io/badge/License-GPLv3-blue.svg)](https://www.gnu.org/licenses/gpl-3.0)
[![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)


Fourier Power Function Shapelets (`FPFS`) is an innovative estimator for the
shear responses of galaxy shape, flux, and detection. Utilizing leading-order
perturbations of shear (a vector perturbation) and image noise (a tensor
perturbation), `FPFS` determines shear and noise responses for both
measurements and detections. Unlike traditional methods that distort each
observed galaxy repeatedly, `FPFS` employs analytical shear responses of select
basis functions, including Shapelets basis and peak basis. Remarkably
efficient, `FPFS` can process approximately 1,000 galaxies within a single CPU
second. Testing under simple simulations has proven its capability to maintain
a multiplicative shear estimation bias below 0.5%, even amidst blending
challenges. For further details, refer to the `FPFS` module documentation
[here](https://fpfs.readthedocs.io/en/latest/).

----

## Installation

For stable (old) version, which have not been updated:
```shell
pip install fpfs
```

Or clone the repository:
```shell
git clone https://github.com/mr-superonion/FPFS.git
cd FPFS
pip install -e . --user
```

Before using the code, please setup the jax environment
```shell
source fpfs_config
```
----

## Reference
The following papers are ready to be cited if you find any of these papers
interesting or use the pipeline. Comments are welcome.

+ **version 3:** [Li & Mandelbaum
  (2022)](https://ui.adsabs.harvard.edu/abs/2022arXiv220810522L/abstract)
  correct for detection bias from pixel level by interpreting smoothed pixel
  values as a projection of signal onto a set of basis functions.

+ **version 2:** [Li , Li & Massey
  (2022)](https://ui.adsabs.harvard.edu/abs/2021arXiv211001214L/abstract)
  derive the covariance matrix of FPFS measurements and corrects for noise bias
  to second-order. In addition, it derives the correction for selection bias.

+ **version 1:** [Li et. al
  (2018)](https://ui.adsabs.harvard.edu/abs/2018MNRAS.481.4445L/abstract)
  build up the FPFS formalism based on
  [Fourier_Quad](https://arxiv.org/abs/1312.5514) and [polar
  shapelets](https://arxiv.org/abs/astro-ph/0408445).
----

## Development

Before sending pull request, please make sure that the modified code passed the
pytest and flake8 tests. Run the following commands under the root directory
for the tests:

```shell
flake8
pytest -vv
```

----
jemawa 1.1.7
Python CLI tool that spam the mentimeter live vote
Keywords: mentimeter menti spammer k1m0ch1

```
    _  ___  __  __    _   __      __   _
 _ | || __||  \/  |  /_\  \ \    / /  /_\
| || || _| | |\/| | / _ \  \ \/\/ /  / _ \
 \__/ |___||_|  |_|/_/ \_\  \_/\_/  /_/ \_\

Mentimeter Manipulator
```

I know this is stupid but its fun, my company using this to vote "something" for a fun event, so I think it will be fun to makes a good laugh for a day in front everyone, so thats it, I create this tools only for fun.

This tools is created experimented for the mentimeter platform.

> DISCLAIMER or USE AT YOUR OWN RISK, These tools should be considered for educational and research purposes only, this tools is made not to violate the law or abuse the system. Any action you take by using this tools is strictly at your own risk. The creator is not responsible for any action

TL;DR version :

Click the video to see how it work.

[![Jemawa](https://img.youtube.com/vi/sVb0bos-vkQ/0.jpg)](https://www.youtube.com/watch?v=sVb0bos-vkQ "JEMAWA the mentimeter multiple choice vote spammer")

## How to use ?

we publish on pypi, you could run jemawa by install with this command

```
pip install jemawa
```

after that you can run `jemawa` command

```
jemawa <mentimeter vote page link or menti code> <optional command>
```

example

```
jemawa https://www.menti.com/alg3v6yduhsr
```

or

```
jemawa 26876868
```

Optional Command list:
`ls` to list all the question alongside with ID
`slide_id` to direct vote to the slide

Currently Slide Type we can spam is:
1. Multiple Choice
2. Ranking Type <FIXING>
3. Wordcloud <FIXING>
4. Open Ended
5. Scales 
6. Q&A
7. 2x2 grid vote

## Custom page vote

Now you can vote on any page not by only presented page, to do this you can run this

```
jemawa <link> questions
```

to list the questions, after that get the question ID and run this

```
jemawa <link> <questionID>
```

so it will continue like normal

## How this is work?

alright so you want to know, actually you can spam vote by creating a new session or a new identifier to every vote, you know its like whenver you want to vote, just simply open a new private browser, and vote.

so this is how program work.

1. We need to get which page is presented by presenter
2. get the content of the vote, ID and label
3. choose the ID to vite
4. tell the tools much vote you want
5. bot will get a new identifier for voting
6. and just vote.

## What is jemawa ?

indonesian word for 'arrogant'

## Development

to run the development, use the `python dev.py ..`

## Contributors

![GitHub Contributors Image](https://contrib.rocks/image?repo=k1m0ch1/jemawa-menti-choices-spammer)
vqapi 0.6.4.40
ViQi Python API
Requires Python: >=3.8

# ViQi API

Low level interface to ViQi services


## Install


`pip install viqi-api `

## Configuration

For command line tools create `~/.config/viqi/profiles` with the following

```
[default]
host=https://science.viqiai.cloud
user=myuser
password=mysecret

[science-user2]
host=https://science.viqiai.cloud
user=myuser2
password=mysecret2
```

## Usage

Example ipython session:

```
ipython
from vqapi import bisque_session
session = bisque_session(args=["--profile=science-user2"])

meta = session.service("meta")
user = meta.fetch("user")
print(user)

```