semvec/pypi-packages huggingface dataset:
kaydet 0.8.6
Simple and terminal-based personal diary app designed to help you preserve your daily thoughts, experiences, and memories.
License: MIT
Requires Python: >=3.4
Keywords: diary tui

# Kaydet is Your Personal Terminal Diary

"kaydet" is a simple (112 lines if Python code) based diary app designed to
help you preserve your daily thoughts, experiences, and memories without 
leaving terminal.

# How to Install?

    $ pip3 install kaydet

# Key Features:

## Short Entries

Record your daily thoughts and experiences by typing them as a parameter in
the terminal. "kaydet" automatically saves your entry to a file dedicated to
the current day, along with a timestamp.

    $ kaydet "I am very good with my kids today :)"
    > Entry added to: /Users/mirat/.kaydet/2023-08-02.txt

## Long Entries

If you don't give any parameters to "kaydet" it opens your favourite text
editor to allow you to create long entries.

    $ kaydet

## Time-Stamped Entries

Each diary entry is precisely dated, ensuring your thoughts are organized
chronologically for easy navigation and reflection.

## Trustless

"kaydet" uses txt files to store your entries, guaranteeing your diary
remains private and secure on your own hard disk. You don't have to trust me,
or any company.

## Synch in Your Way

Do you want to synch your diary entries between your devices? You can use any
folder synchronization service that you trust.

## Customizable Settings

You can configure "kaydet" to your preferences with customizable options,
including file naming conventions, text editor that you want to use, entry
format.
django-channels-jwt 0.0.3
Secure JWT Auth Middleware for Django Channels
License: MIT
Requires Python: >=3.8
Keywords: django,channels,jwt,auth,middleware,python,authentication

# Django Channels JWT 

Django Channels JWT Middleware is a secure way to handle authentication for Django Channels WebSocket connections without directly exposing JWT tokens. Instead of sending the token itself in the query parameter, this middleware uses UUID-based authentication and cache-based user retrieval for enhanced security.

## Security Benefits

- **Enhanced Security**: JWT tokens can potentially be intercepted if sent as query parameters. This middleware avoids sending tokens directly, minimizing the risk of token leakage.

- **UUID-based Authentication**: This middleware generates UUIDs as tokens for WebSocket connections. These UUIDs are short-lived and act as temporary access keys. When a user connects, they provide the UUID, which is used to retrieve the authenticated user.

- **Cache-based User Retrieval**: Upon connection, the middleware validates the UUID, retrieves the corresponding user ID from the cache, and fetches the user asynchronously. This ensures that the WebSocket connection is only established for authenticated users.

## Risks of Sending Tokens as Query Parameters

Sending tokens as query parameters can expose security vulnerabilities:
- **Token Exposure**: Tokens in query parameters can be captured in logs, browser history, or server logs, increasing the risk of unauthorized access.
- **Caching**: Some proxies or servers may cache URLs, which could lead to tokens being stored in shared caches.

## Installation

Install the package using pip:

```bash
pip install django-channels-jwt
```

## Configuration

1. Wrap your URLRouter
   ```python
   from django_channels_jwt.middlware import JwtAuthMiddlewareStack

   application = ProtocolTypeRouter({
       "http": get_asgi_application(),
       "websocket": JwtAuthMiddlewareStack(
           URLRouter(
               websocket_urlpatterns,
           )
       ),
   })
   ```

2. Include the provided URL for ticket generation in your project's `urls.py`:

  ```python
   from django.urls import path, include

   url_patterns = [
       # ... your other URL patterns
       path("api/auth/", include('django_channels_jwt.urls')
   ]
   ```
or if you want to set customized route

   ```python
   from django.urls import path, include
   from django_channels_jwt.views import AsgiValidateTokenView

   url_patterns = [
       # ... your other URL patterns
       path("auth_for_ws_connection/", AsgiValidateTokenView.as_view())
   ]
   ```

## Usage

1. Ensure your Django app's models are configured correctly.
2. Use the included `AsgiValidateTokenView` to generate a ticket (UUID) for WebSocket connections.
3. Connect to your WebSocket with the generated UUID to authenticate the connection without exposing the token.
 ```
 ws://localhost:8001/ws/chat/?uuid=
 ```


1.0.0 (2023-08-11)
------------------

* First release on PyPI.
faiss-imputer 0.1.1
Impute missing values using faiss
License: MIT

# FaissImputer

[![PyPI Version](https://img.shields.io/pypi/v/faiss-imputer.svg)](https://pypi.org/project/faiss-imputer/)
[![License](https://img.shields.io/pypi/l/faiss-imputer.svg)](https://github.com/your-username/FaissImputer/blob/main/LICENSE)

Impute missing values using faiss - A Python library for missing data imputation with k nearest neighbors.

## Installation

You can install `faiss-imputer` using `pip`:

```bash
pip install faiss-imputer
```

## Usage

```python
import pandas as pd
from faiss_imputer import FaissImputer

# Create your DataFrame and introduce missing values
# ...

# Create an instance of FaissImputer
imputer = FaissImputer(n_neighbors=3)

# Fit the imputer on the data frame with missing values
imputer.fit(df_missing)

# Transform the data frame with missing values
df_imputed = imputer.transform(df_missing)
```

## Parameters

**n_neighbors:** Number of nearest neighbors to consider for imputation.
**metric:** Distance metric to use for nearest neighbor search ('l2' or 'ip').
**strategy:** Imputation strategy ('mean' or 'median').
**index_factory:** Faiss index type ('Flat' or others).

## Example

For a detailed example, refer to the example.py file.

## Contributing

Contributions are welcome! If you find a bug or have an enhancement suggestion, please open an issue or create a pull request.

## License

This project is licensed under the [MIT License](LICENSE).

### Third-Party Licenses

This project utilizes code from Meta's Faiss library, which is distributed under the [Apache License 2.0](https://github.com/facebookresearch/faiss/blob/master/LICENSE).

Please note that while this project includes code from the Faiss library, it is not officially associated with or endorsed by the Faiss maintainers or Meta.

For detailed licensing information of the Faiss library, please refer to the [Faiss repository](https://github.com/facebookresearch/faiss).
django-countries-geoextent 0.0.1
Country geographic extent plugin for Django Countries
License: MIT
Requires Python: >=3.9

# Django Countries GeoExtent

This package adds a `geo_extent` attribute to
the `django-countries` [Country](https://github.com/SmileyChris/django-countries#the-country-object) object.

The `geo_extent` attribute represents the geographic extent of a country, as extracted
from [GADM 4.1](https://gadm.org/download_world.html) boundaries data.

## Installation

```
pip install django-countries-geoextent
```

## Usage

Once installed, use the [Django Country](https://github.com/SmileyChris/django-countries#the-country-object) as
described in the [docs](https://github.com/SmileyChris/django-countries).

A new attribute named `geo_extent` will be added to a Country object instance, that represents the geographic extent of
the country, as obtained from [GADM 4.1](https://gadm.org/download_world.html) boundaries data.

If a country is not found, the `geo_extent` attribute will be `None`