semvec/pypi-packages huggingface dataset:
pyautoreloadserver 0.0.2
A simple HTTP server that serves files, even on file change

Sure! Here's an updated README.md file based on the new code base:

# PyAutoReloadHTTPServer

PyAutoReloadHTTPServer is a simple Python package that provides an HTTP server with automatic reloading functionality. It allows you to serve static files and dynamically reload them whenever they are modified, created, or destroyed. You no longer have to restart your local server to load changed files, this will serve files as they're added and changed. Give it a shot!

## Installation

You can install PyAutoReloadServer using pip:

```bash
pip install pyautoreloadserver
```

## Usage

The easiest way to run it, is to use it from the command line

```shell
pyautoreloadserver -n localhost -p 5555 -r .
```

The flags above can be summarized as follows

- `n`: the hostname
- `p`: the port
- `r`: the root directory to monitor

To use PyAutoReloadHTTPServer, create an instance of the `AutoReloadHTTPServer` class and call the `serve` method to start the server. By default, the server listens on `localhost` and port `8000`, and serves files from the current directory.

```python
from pyautoreloadserver import AutoReloadHTTPServer

# Create an instance of AutoReloadHTTPServer
server = AutoReloadHTTPServer()

# Start the server
server.serve()
```

You can customize the server behavior by providing optional arguments to the `AutoReloadHTTPServer` initializer:

- `host` (str): The hostname or IP address to bind the server to (default: "localhost").
- `port` (int): The port number to listen on (default: 8000).
- `root` (str): The root directory to serve files from (default: ".").
- `delay` (float): The delay between serving requests (default: 0.001 seconds).
- `ServerClass` (TCPServer): The server class to use (default: HTTPServer).
- `RequestHandlerClass` (BaseHTTPRequestHandler): The request handler class to use (default: SimpleHTTPRequestHandler).

```python
from pyautoreloadserver import AutoReloadHTTPServer

# Create an instance of AutoReloadHTTPServer with custom options
server = AutoReloadHTTPServer(host="0.0.0.0", port=8080, root="/path/to/files")

# Start the server
server.serve()
```

Once the server is running, you can visit the specified host and port in your web browser to access the served files.

To stop the server, call the `stop` method:

```python
server.stop()
```

Although you'll probably want to start this in a separate thread/process because the server is running a loop that may block.

## Logging

PyAutoReloadHTTPServer logs informational messages using the `logging` module. By default, the log level is set to `logging.INFO`, but you can configure it according to your needs.

```python
import logging

# Set the log level to DEBUG for more detailed logs
logging.basicConfig(level=logging.DEBUG)
```

## Contributing

Contributions to PyAutoReloadHTTPServer are welcome! If you find a bug, have a feature request, or want to contribute code, please open an issue or submit a pull request on the [GitHub repository](https://github.com/jay3ss/pyautoreloadserver).

## License

This project is licensed under the [MIT License](LICENSE).
theendisnever 1.1.0
A package to easily make an LLM talk with itself for eternity.
Requires Python: >=3.7

# [The End is Never](pypi.org/project/theendisnever/)

A package to make an LLM talk with itself for eternity.

```python
from theendisnever.theend import isnever
isnever(
  model_name='Fredithefish/ScarletPajama-3B-HF', # Default LLM
  prompt='THE END IS NEVER THE END IS NEVER ', # Default prompt
  max_memory_ratio=0.25 # Default % of latest tokens to remember
)
```

## Notes

For the default LLM (which you can change as shown above), you'll need at least:

- ~ 6GB of free disk space
- ~ 15GB of RAM

When running `isnever()` for the first time, it will download the model and tokenizer from HuggingFace. This will take a while, but it only needs to be done once.

If you want to use the CPU (not recommended because it's slow, but it works), make sure you have [PyTorch for CPU](https://pytorch.org/get-started/locally/) installed.

## Contributing

1. Install conda if necessary:

    ```bash
    # Install conda: https://conda.io/projects/conda/en/latest/user-guide/install/index.html#regular-installation
    # If on Windows, install chocolately: https://chocolatey.org/install. Then, run:
    # choco install make
    ```

1. Create the conda environment and install pip packages locally:

    ```bash
    git clone https://github.com/andrewhinh/theendisnever.git
    cd theendisnever
    conda env update --prune -f environment.yml
    conda activate theendisnever
    pip install -r requirements.txt
    ```

1. Make your changes.
  a. Remember to update the `requires` and `version` fields in `pyproject.toml` as necessary

1. Run `python -m build` to build the package, removing old builds from dist/ first if necessary.
1. Run `python -m twine upload --repository theendisnever dist/*` to upload the package to TestPyPI.
1. Run `pip install --index-url https://test.pypi.org/simple/ --no-deps --upgrade theendisnever` in a fresh environment to test the package.
1. Once confirmed to work, make a PR from a feature branch to main on GitHub.
1. Once PR is merged, [email me](ajhinh@gmail.com) to be added as a collaborator on PyPI.
1. Once added as a collaborator, run `python -m twine upload dist/*` to upload the package to PyPI.