semvec/pypi-packages huggingface dataset:
reloadify 0.1.16
A blazing-fast, ultra-lightweight Python CLI tool for live-reloading web content.
Requires Python: >=3.7

# Reloadify 🚀

Welcome to **Reloadify**! A super-fast, feather-light Python tool that automatically reloads your HTML, CSS, and JavaScript files in the browser while you code. Say goodbye to manual refreshing! 👋

## 🌟 Features

-   **⚡ Blazing Fast:** Built for speed and efficiency.
-   **🤏 Ultra-Lightweight:** No heavy dependencies, just pure performance.
-   **🔄 Live Reloading:** Instantly see your changes in the browser.
-   **🛠️ Customizable:** Easily configure the file, directory, and port.

## 📦 Installation

Getting started is as easy as pie! Just open your terminal and run:

```bash
pip install reloadify
```

## 🚀 Usage

Once installed, navigate to your project's folder and let the magic happen!

```bash
reloadify [FILE]
```

-   `[FILE]` (optional): This is your main HTML file. If you don't specify one, `reloadify` will search the current directory and all subdirectories for `.html` files. If multiple `.html` files are found, it will prompt you to select one. If only one is found, it will be served automatically.

### ⚙️ Options

You can customize `reloadify` to fit your needs:

-   `-d, --directory <PATH>`: Tell `reloadify` which specific folder to watch for changes.

    *Example:*
    ```bash
    # Watch the 'src' folder for changes
    reloadify -d ./src
    ```

-   `-p, --port <PORT>`: Choose a custom port to run the server on. The default is `4005`.

    *Example:*
    ```bash
    # Run on port 8000
    reloadify -p 8000
    ```

-   `-t, --timeout <SECONDS>`: Automatically shut down the server after a specified number of seconds.

    *Example:*
    ```bash
    # Shut down after 60 seconds
    reloadify -t 60
    ```

### ✨ Examples

Here are a few ways you can use `reloadify`:

-   **Serve `index.html` and watch its folder (the default way):**
    ```bash
    reloadify
    ```

-   **Serve a specific HTML file and watch its folder:**
    ```bash
    reloadify my_app/index.html
    ```

-   **Serve `index.html` but watch a different folder for changes:**
    ```bash
    reloadify index.html -d ./src
    ```

-   **Serve `index.html` on a different port:**
    ```bash
    reloadify -p 8080
    ```

## 🌐 Connect with Me!

-   **Discord:** `lousybook01` 💬
-   **GitHub:** [LousyBook94](https://github.com/LousyBook94/) 🐙
-   **YouTube:** [@LousyBook01](http://youtube.com/@LousyBook01) 📺


## 🤝 Contributing

Contributions are welcome! If you'd like to help improve reloadify, please follow these steps:

1.  **Fork the repository.**
2.  **Create a new branch.**
3.  **Set up a virtual environment:**
    ```bash
    python -m venv venv
    source venv/bin/activate
    ```
4.  **Install the dependencies:**
    ```bash
    pip install -r requirements.txt
    ```
5.  **Make your changes.**
6.  **Run the tests:**
    ```bash
    pytest
    ```
7.  **Submit a pull request.**

## 📝 License

This project is licensed under the MIT License.
See the [LICENSE](./LICENSE) file for details.

---

*Made with ❤️ by LousyBook & Gemini.*
layered-persistence 0.0.3
Persistence
Requires Python: >=3.7
Keywords: layers, persistence, storage

# layered-persistence

[![PyPI version](https://img.shields.io/pypi/v/layered-persistence.svg)](https://pypi.org/project/layered-persistence/) [![License](https://img.shields.io/github/license/ceil-python/persistence)](https://github.com/ceil-python/persistence/blob/main/LICENSE)

**Flexible, multi-layer key-value persistence library for Python and MicroPython. In-memory, file, and HTTP storage, with simple pluggable API.**

---

## Features

- Persistent key-value storage with multiple, cascading "layers"
- Storage backends: RAM, JSON file, remote HTTP
- Supports async and sync use
- Lightweight, only core Python dependencies
- Optional HTTP server for networked persistence

---

## Installation

```sh
pip install layered-persistence
```

or

```sh
python -m pip install layered-persistence
```

or

```sh
python3 -m pip install layered-persistence
```

---

## Quickstart

```python
from layered_persistence import LayeredPersistence, RuntimeLayer, FileLayer

# Use both in-memory (fast) and file (persistent) layers
store = LayeredPersistence(layers=[
    RuntimeLayer(),
    FileLayer(directory="./data")
])

# Store and retrieve a value
await store.set('foo', {'bar': 123})
val = await store.get('foo')
await store.set('foo', {'bar': val["value"]["bar"]+1})
print(val)  # {'value': {'bar': 123}}
```

---

## Layers

- **`RuntimeLayer`** — Fastest, memory only, cleared on reboot.
- **`FileLayer`** — Stores each key as `./directory/key.json`.
- **`HttpLayer`** — For network/remote server persistence (see docs).

Layers can be stacked; reads backfill for speed, writes cascade for durability.

---

## HTTP Server

Expose your store as a simple HTTP API:

```python
from layered_persistence import serve_via_http, LayeredPersistence, RuntimeLayer

store = LayeredPersistence([RuntimeLayer()])
serve_via_http(store, port=8080)
```

---

## License

MIT
microenv 0.1.5
Functional dependency paradigm
Requires Python: >=3.7
Keywords: env, environment, micro, microenv

# microenv

[![PyPI version](https://img.shields.io/pypi/v/microenv.svg)](https://pypi.org/project/microenv/)
[![License](https://img.shields.io/pypi/l/supply-demand.svg)](LICENSE)

A minimal Python environment abstraction with privacy controls and async “next” subscriptions.

## Installation

```bash
pip install microenv
```

or

```bash
python -m pip install microenv
```

or

```bash
python3 -m pip install microenv
```

## Quickstart

```python
import asyncio
from microenv import microenv

# Define initial data and optional descriptor
data = {"public": 1, "secret": "s3cr3t"}
descriptor = {
    "children": [
        {"key": "public", "type": "number"},
        {"key": "secret", "type": "string", "private": True},
    ]
}

# Create the environment
env = microenv(obj=data, descriptor=descriptor)
face = env.face

# Basic get / set via the face
print(face.public)         # → 1
face.public = 42
print(env.data["public"])  # → 42

# Privacy: direct .secret bypasses privacy checks on the face
print(face.secret)         # → "s3cr3t"
face.secret = "new!"
print(env.data["secret"])  # → "new!"

# Async “next” subscription: await the next update to a key
async def wait_for_update():
    fut = env.get("public", next_=True)
    print("waiting for next public…")
    val = await fut
    print("new public value:", val)

# Schedule waiter and then update
loop = asyncio.get_event_loop()
loop.create_task(wait_for_update())
loop.call_soon(lambda: setattr(face, "public", 99))
loop.run_forever()
```

## API

- `microenv(obj: dict, descriptor: dict = None) → MicroEnv`
  - `env.face` : proxy for getting/setting properties.
  - `env.get(key, caller=None, next_=False)` : synchronous read or, if `next_=True`, a Future resolving on next `set`.
  - `env.set(key, value, caller=None)` : update a property, resolving any pending “next” futures.

## License

This project is licensed under the MIT License.  
See [LICENSE](https://github.com/ceil-python/microenv/blob/main/LICENSE) for details.
django-project-skeleton 0.1.0
Un outil pour créer un squelette de projet Django avec config et une application personnalisée
Requires Python: >=3.8

# Django Project Skeleton

Un outil pour créer un squelette de projet Django avec un dossier 'config' pour la configuration et un dossier d'application personnalisé.

## Installation
```bash
pip install django-project-skeleton
pyrad2 1.2.0
RADIUS Server
Requires Python: >=3.12

<img src="docs/logo.png" width="10%" height="auto"> 

[![Tests](https://github.com/nicholasamorim/pyrad2/actions/workflows/python-test.yml/badge.svg)](https://github.com/miraclesupernova/stickystack/actions/workflows/django.yml)
[![python](https://img.shields.io/badge/Python-3.12+-3776AB.svg?style=flat&logo=python&logoColor=white)](https://www.python.org)
[![pre-commit](https://img.shields.io/badge/pre--commit-enabled-brightgreen?logo=pre-commit&logoColor=white)](https://github.com/pre-commit/pre-commit)
[![Code style: ruff](https://img.shields.io/badge/code%20style-ruff-000000.svg)]([https://github.com/psf/black](https://github.com/astral-sh/uv))
[![Checked with mypy](http://www.mypy-lang.org/static/mypy_badge.svg)](http://mypy-lang.org/)

pyrad2 is an implementation of a RADIUS client/server as described in RFC2865 and of RADSEC client/server as described in RFC6614. It takes care of all the details like building RADIUS packets,sending them and decoding responses.

**Documentation can be found [here](https://nicholasamorim.github.io/pyrad2/).**

# Introduction

[pyrad2](https://github.com/nicholasamorim/pyrad2) is an implementation of a RADIUS client/server as described in RFC2865. It takes care of all the details like building RADIUS packets, sending them and decoding responses.

What this fork does:
   
- Adds RadSec (RFC 6614) support (Experimental)
- Supports only Python 3.12+
- Extensive typing
- Increased test coverage
- New bug fixes

Note that this is _not_ a stand-alone Radius implementation like [FreeRadius](https://www.freeradius.org). You are supposed to inherit the server classes and code your own behind-the-scenes implementation. This package allows you to code your business logic on top of it.

# Requirements & Installation

pyrad2 requires Python 3.12 and uses [uv](https://github.com/astral-sh/uv). On a Mac, you can simply run `brew install uv`.

# Examples

See the [Getting Started guide](https://nicholasamorim.github.io/pyrad2/setup/) for a better overview.

There are a few examples in the `examples` folder. You can either install pyrad2 and use the examples or clone the repo. If you clone the repo, make commands are useful.

The easiest way to start a server is by running `make server`. This will run the example server in `examples/server_async.py`.

If you want to see a request in action, leave the server running, open another terminal and type `make auth`. Several other commands are available such as `make server_radsec`, `make server_coa`, `make_acct`, etc.

# Tests

Run `make test`.

# Author, Copyright, Availability

pyrad2 is currently maintaned by Nicholas Amorim \<<nicholas@santos.ee\>.

pyrad was written by Wichert Akkerman \<<wichert@wiggy.net>\> and is
maintained by Christian Giese (GIC-de) and Istvan Ruzman (Istvan91).

This project is licensed under a BSD license.

Copyright and license information can be found in the LICENSE.txt file.

The current version and documentation can be found on pypi:
<https://pypi.org/project/pyrad2/>

Bugs and wishes can be submitted in the pyrad issue tracker on github:
<https://github.com/nicholasamorim/pyrad2/issues>