semvec/pypi-packages huggingface dataset:
caravanassets 0.1.3
This is a python package for implementing the card game Caravan
License: MIT
Requires Python: >=3.9
Keywords: caravan,card,cardgame,game,fallout

# why?
This Python package will help you implement the Caravan card game.

The most important thing it does is add cards to the caravan pile using the "add_card" method. If it is impossible to add a card, the caravan does not change.

It also has several auxiliary methods, such as "price" - which allows you to estimate the cost of a caravan, or "direction_check", which allows you to determine the direction of the stack (increasing or descending).

Playing cards are implemented using the "Card" class, which contains the name of the card and its suit.

So far this package does not contain manipulations with the Joker card, but it will be added in the future. (maybe)

# jack add instruction

You must enter a list of cards [name1, suit1, name2, suit2...], where name (1-13) are in odd places, and suit (1-4) are in even places. The sequence of cards must be a valid caravan. (there should be no jacks in it, and the number card should come first).

You also need to select the card on which you want to place the jack. Jack can only be placed on number cards.

For example, you can use `python -m caravanassets -cards "[1, 2, 3, 4, 13, 2, 4, 2]"` 
output:
`Three Clubs
King Diamonds
Four Diamonds`

by default the program uses jack on the first card

but if you need to use it on other card, you can use
`python -m caravanassets -cards "[1, 2, 3, 4, 13, 2, 4, 2]" -addj 2` 
output:
`Ace Diamonds
Four Diamonds`

the jack removed the second card, and all the picture cards on it.

# input

-cards / --caravan (necessary)

-addj / --addjack (not necessary)

# installation
`pip install caravanassets`
jimGW 0.1.1
Gravitatioanl wave data analysis tool in Jax
License: MIT
Requires Python: >=3.9
Keywords: sampling,inference,machine learning,normalizing,autodiff,jax

# Jim <img src="https://user-images.githubusercontent.com/4642979/218163532-1c8a58e5-6f36-42de-96d3-f245eee93cf8.png" alt="jim" width="35"/> - A JAX-based gravitational-wave inference toolkit

Jim comprises a set of tools for estimating parameters of gravitational-wave sources thorugh Bayesian inference.
At its core, Jim relies on the JAX-based sampler [flowMC](https://github.com/kazewong/flowMC),
which leverages normalizing flows to enhance the convergence of a gradient-based MCMC sampler.

Since its based on JAX, Jim can also leverage hardware acceleration to achieve significant speedups on GPUs. Jim also takes advantage of likelihood-heterodyining, ([Cornish 2010](https://arxiv.org/abs/1007.4820), [Cornish 2021](https://arxiv.org/abs/2109.02728)) to compute the gravitational-wave likelihood more efficiently.

See the accompanying paper, [Wong, Isi, Edwards (2023)](https://github.com/kazewong/TurboPE/) for details.

_[Documentatation and examples are a work in progress]_

## Installation

You may install the latest released version of Jim through pip by doing
```
pip install jimGW
```

You may install the bleeding edge version by cloning this repo, or doing
```
pip install git+https://github.com/kazewong/jim
```

If you would like to take advantage of CUDA, you will additionally need to install a specific version of JAX by doing
```
pip install --upgrade "jax[cuda]"==0.4.1 -f https://storage.googleapis.com/jax-releases/jax_cuda_releases.html
```

_NOTE:_ Jim is only currently compatible with Python 3.10.

## Performance

The performance of Jim will vary depending on the hardware available. Under optimal conditions, the CUDA installation can achieve parameter estimation in ~1 min on an Nvidia A100 GPU for a binary neutron star (see [paper](https://github.com/kazewong/TurboPE/) for details). If a GPU is not available, JAX will fall back on CPUs, and you will see a message like this on execution:

```
No GPU/TPU found, falling back to CPU.
```

## Directory

Parameter estimation examples are in `example/ParameterEstimation`.

## Attribution

Please cite the accompanying paper, [Wong, Isi, Edwards (2023)](https://github.com/kazewong/TurboPE/).
compute-oper 0.0.1
Trial Basic calculator library, individual functions
License: MIT
Keywords: basic,calculator

This is a very simple calculator that takes 2 numbers and performs relevant mathematical computations on them

Change Log

=============================

0.0.1 - 18-09-2023 -- First release

0.0.1.1 -- 18-09-2023 --  updated release to check if it works
dash-auth0 0.1.6
Authenticate your Dash app with Auth0
License: MIT
Requires Python: >=3.10,<4.0

# Dash Auth0

This is a simple library using Auth0 OAuth2.0 to authenticate and view a Dash app
written based on [dash-auth](https://github.com/plotly/dash-auth) and [dash-google-oauth](https://github.com/hossein-jazayeri/dash-google-oauth).
Upon authentication, a cookie is created and kept for 2 weeks.

### Setup

Setup an Auth0 tenant and application.

Add <your_app_base_url>/login/callback as allowed callback url and <your_app_base_url> as allowed logout url in the Auth0 Application settings.
For example:

    allowed callback url: https://www.myapp.com/login/callback
    allowed logout url:   https://www.myapp.com

Install the package:

```
poetry add git+https://github.com/flojoy-ai/dash-auth0.git#master
```

Define following environment variables:

```
FLASK_SECRET_KEY

AUTH0_AUTH_URL
AUTH0_AUTH_SCOPE
AUTH0_AUTH_TOKEN_URI
AUTH0_AUTH_USER_INFO_URL
AUTH0_AUTH_CLIENT_ID
AUTH0_AUTH_CLIENT_SECRET
AUTH0_LOGOUT_URL
AUTH0_API_AUDIENCE
AUTH_FLASK_ROUTES
```

for example

```
FLASK_SECRET_KEY="<some secret key>"

AUTH0_AUTH_URL="https://<your tenant url>/authorize"
AUTH0_AUTH_SCOPE="openid profile email"
AUTH0_AUTH_TOKEN_URI="https://<your tenant url>/oauth/token"
AUTH0_AUTH_USER_INFO_URL="https://<your tenant url>/userinfo"
AUTH0_AUTH_CLIENT_ID="<your app client id>"
AUTH0_AUTH_CLIENT_SECRET="<your app client secret>"
AUTH0_LOGOUT_URL="https://<your tenant url>/v2/logout"
AUTH0_API_AUDIENCE="<your_api_audience_identifier>"
AUTH_FLASK_ROUTES="true"
```

Add it to the application:

```
app = Dash(__name__)

from dash_auth0_oauth.auth0_auth import Auth0Auth
auth = Auth0Auth(app)
```

You have access to `/logout` route in order to logout user by making a `GET` request.

User's name stored in cookie: `flask.request.cookies.get('AUTH-USER')`