semvec/pypi-packages huggingface dataset:
latentmi 0.1.3
approximating mutual information in high dimensions
License: MIT
Requires Python: <4.0,>=3.9

# latentmi

Latent MI (LMI) approximation is a method for estimating mutual information high dimensions. It is built on the idea that real world high-dimensional data has underlying low-dimensional structure. For more details, see our [manuscript](linkcomingsoon). `latentmi` is our Python implementation of LMI approximation, built with the hope that practicioners can use it with minimal pain and suffering :) 


## Installation

```bash
$ pip install latentmi
```

## Usage

```python
from latentmi import lmi

Xs = # some samples of a high dimensional variable
Ys = # some samples of a high dimensional variable

pmis, embedding, model = lmi.lmi(Xs, Ys)

MI_estimate = np.nanmean(pmis) # voila !
```

More detailed instructions can be found in the example usage notebook.


## License

`latentmi` was created by Gokul Gowri. It is licensed under the terms of the MIT license.

## Credits

`latentmi` was created with [`cookiecutter`](https://cookiecutter.readthedocs.io/en/latest/) and the `py-pkgs-cookiecutter` [template](https://github.com/py-pkgs/py-pkgs-cookiecutter).
sitemappy-cli 1.0.5
A Python library for crawling a website and returning a sitemap.
License: MIT
Requires Python: >=3.12

## 📖 About 

Sitemappy (or sitemap-py 😉) is a crawler that produces a sitemap for a given website.

Sitemappy is a command-line application, and also provides Python interfaces for use as a library.

### Features

- [x] Print the URL for a given website when visited
- [x] Print the links for a given webpage
- [x] Visit the links for a given webpage
- [x] Limit the links to follow on a webpage to the same single subdomain
- [x] Concurrency (`asyncio`, `multithreading`, `multiprocessing`)
- [x] Output crawling results to file by default (results too long for console)
- [x] Modify number of async crawler workers
- [x] Specify crawling depth
- [x] Crawling politeness argument
- [ ] Follow HTTP redirect responses
- [ ] HTTP error response handling
- [ ] Add DEBUG, INFO and ERROR logging
- [ ] Adhere to a website's `robots.txt`
- [ ] "Spider Trap" resilience
- [ ] Introduce `multiprocessing`
- [ ] Distributed multiprocessing
- [x] Publish to PyPi 🚀
- [x] GitHub Workflows (deploy)
- [ ] GitHub Workflows (linting, unit testing, dev deployments)

## 🚀 Usage

Generate a sitemap (`./results.json`):

```shell
sitemappy-cli https://monzo.com/
```

### Help

```shell
$ sitemappy-cli --help
usage: sitemappy-cli [-h] BASE_URL

Sitemappy is a CLI tool to crawl a website and create a sitemap.
For more information about the tool go to https://github.com/dan-wilton/sitemappy/

Arguments:
  BASE_URL              a valid website URL to sitemap [required]

Options:
  --workers           INTEGER     Number of workers to asynchronously 
                                  make web requests [default: 10]
  
  --crawl-depth       INTEGER     Depth of links from base URL to follow
                                  [default: 0 - unlimited]
  
  --politeness-delay  INTEGER     Delay between each request to the website
                                  [default: 0 - none]
  
  --enable-cmd-out                Print output to cmd
  
  --help                          show this help message and exit
```


## 🎒 Requirements 

[Python](https://www.python.org/downloads/) `3.12+`


### Development 

[PDM](https://pdm-project.org/en/latest/)


## 💻 Installation

To use the sitemappy CLI:

```shell
pip install --user -U sitemappy-cli
```

### Local Development / Contributing

```shell
pdm install
```

Run the tests with:

```shell
pytest -v
```

### Python Library

Use sitemappy in your project with one of the following:

with **pip**:

```bash
pip install -U sitemappy-cli
```

with **PDM**:

```bash
pdm add sitemappy-cli
```

with **Poetry** >= 1.2.0:

```bash
poetry add sitemappy-cli
```

### macOS

> **_NOTE:_** This is not yet enabled 😢

via [homebrew](#macos):

```bash
brew install sitemappy-cli
```
django-typeid-field 0.0.1
TypeID Field for Django
License: MIT
Keywords: django, typeid, django-field

# Django TypeID Field

TypeID is a type-safe extension of UUIDv7, encoding UUIDs in base32 and adding a type prefix. This package provides a field to use in models. For more details about TypeID, visit the [TypeID GitHub repository](https://github.com/jetify-com/typeid).

## Installation

Install it from PyPI:

```sh
pip install django-typeid-field
```


## Usage

First, add it to your applications (Not Required)

```python
INSTALLED_APPS = [
    # ...
    'typeid_field',
    # ...
]
```

You can now use it in your models like:

```python
from django.db import models
from typeid_field import TypeidField

class Profile(models.Model):
    hash = TypeidField(prefix='profile')
```


## TypeidField

This model field is based on `CharField`. All of it's parameters can be used.

Additionally following fields affects outcome of TypeID:


### `prefix` Parameter (Optional)
Specifies the type prefix for the generated TypeID, which impacts the length of the ID and the field in the database. The prefix can be up to 63 characters long, must contain only lowercase alphabetic ASCII characters or underscores, and cannot start or end with an underscore. If the prefix is empty, no separator is used.


## Using TypeidField as `primary_key`
To use TypeID as default `primary_key` you need to explicitly define it in your
model:

```python
from django.contrib.auth.models import AbstractUser
from django.db import models


class SomeModel(models.Model):
    id = TypeidField(primary_key=True, editable=False) # 2x4y6z8a0b1c2d3e4f5g6h7j8k
    # ...

class CustomUser(AbstractUser):
    id = TypeidField(primary_key=True, editable=False, prefix='user') # user_2x4y6z8a0b1c2d3e4f5g6h7j8k
    # ...
```


## Credits
This package is based on [django-nanoid-field](https://github.com/goztrk/django-nanoid-field).