semvec/pypi-packages huggingface dataset:
xchatbot 0.5.0
the Xtensible XMPP Chat Bot

# The Xtensible XMPP Chat Bot

`XChatBot` is a xmpp bot library written in python using the 
[nbxmpp library from Gajim](https://dev.gajim.org/gajim/python-nbxmpp/)

![](https://readthedocs.org/projects/xchatbot/badge/?version=latest)  
[https://xchatbot.readthedocs.io/](https://xchatbot.readthedocs.io/)

## requirements

- python 3
- pygobject
- nbxmpp

optionally

- pipenv

## install

    pip install xchatbot

## git

    git clone https://git.sr.ht/~fabrixxm/xchatbot

install required packages:

**with pipenv**

    $ pipenv --site-packages --python 3
    $ pipenv install
    $ pipenv run ./xchatbot.py

**on osx** you need first to install python3 with brew:

    $ brew install python3 pipenv pygobject3 libsoup

**on Arch**

    # pacman -S python-gobject python-nbxmpp

**on Debian**

    # apt install python3-gi python3-nbxmpp
clingwrap 2.1
Build bundles of debugging information for system crashes
Requires Python: >=3.7

Clingwrap
=========

Clingwrap is a simple debugging tool which collects information about the state of
a system and stores that information in a zip file for later analysis. It was
originally implemented for the Shaken Fist (https://shakenfist.com) project, but is
more generally useful than that.

Clingwrap takes a configuration file (see examples/shakenfist-ci-failure.cwd for an
example), and processes the list of commands in that file to produce the zip file
of debugging output. The commands are specified in a simple YAML format, where
a configuration file looks like this:

```
--
commands:
  - name: Kernel version and architecture
    destination: _commands/uname
    shell: uname -a

  - name: Installed system OS packages and versions
    destination: _commands/dpkg
    shell: dpkg -l
```

Possible commands are:

*file commands*: which record the contents of a file. For example:

```
  - name: syslog
    destination: var/log/syslog
    file: /var/log/syslog
```

*directory commands*: which record all files in a given directory hierarchy, with a
possible simple exclusion regexp. For example:

```
  - name: Shaken Fist instances
    destination: /srv/shakenfist/instances
    directory: /srv/shakenfist/instances
    exclude: "hd[ac-z]"
```

*shell commands*: which take a command line or script and execute them in a shell. A
valid configuration is:

```
  - name: Kernel version and architecture
    destination: _commands/uname
    shell: uname -a
```

*shell_emitter commands*: which run a shell script which emits further commands to
execute. This is useful for finding objects and then storing information about them.
A valid example is:

```
  - name: Network namespaces
    shell_emitter: |
      for item in `find /var/run/netns -type f | sed 's/.*\///'`
      do
        echo "commands:
      - name: Network interfaces (namespace $item)
        destination: _commands/netns-$item/ip-link
        shell: ip netns exec $item ip link

      - name: Network addresses (namespace $item)
        destination: _commands/netns-$item/ip-link
        shell: ip netns exec $item ip addr

      - name: Network routes (namespace $item)
        destination: _commands/netns-$item/ip-link
        shell: ip netns exec $item ip route
      "
      done
```
ai-stream-proxy 0.1.2
Client SDK for ai-stream-proxy.
Requires Python: <4.0,>=3.10

## Usage

```python
import asyncio

if __name__ == '__main__':
    from ai_stream_proxy import StreamProxyClient
    async def main():
        client = StreamProxyClient(
            server_url="http://127.0.0.1:3000",
            httpx_async_client_options={'proxy': 'http://127.0.0.1:7890'}
        )

        await client.delete_stream(stream_id='test')

        await client.create_stream(
            stream_id='test',
            message_id='haha',
            content_type='claude-code-stream-json+include-partial-messages'
        )

        async with client.new_stream(stream_id="test") as stream:
            with open('some-claude-code-output.jsonl', 'r') as f:
                while True:
                    chunk = f.read(4096)
                    if not chunk:
                        break
                    stream.enqueue(chunk.encode('utf-8'))
            stream.finish(abort=False, reason="Finish")

        await client.wait_for_current_streams()


    asyncio.run(main())
```
efleetscheduler 1.0.4
Electric Fleet Scheduling Optimization Tool
Requires Python: >=3.11

## LCV Schedule Creater
Electric LCV schedule tool

**LCVScheduleCreater** is a Python-based tool designed for the creation of schedules for electric light commercial vehicles (LCV)

## Installation
**1.** Create a new environment or use your own environment and install: Pip install efleetscheduler


## How to use the tool
You can use the entire tool by running the notebook:
- notebooks/Schedule Generation Module.ipynb to create schedules for an electric LCV fleet

## Configurations

The software configuration is structured around four sections that manage the generation of schedules:

Environment configuration (env_config):
    - "original_seed" , is the seed for for random generation of schedulers 
    - "gen_start_date": "yyyy-mm-dd 00:00:00",  start date
    - "gen_end_date", end date
    - "freq": "h",  'h' means hourly frequency. .
    - "EVs", is the number of electric vehicles in the fleet
    - "consumption_factor_file", is path to the CSV file with energy consumption factor

 Schedule generator configurations (sch_config): Define the parameters required to generate the travel and charging patterns for each vehicle in the LCV fleet.
    - "Vehicles number", is Number of vehicles in the fleet
    - "Type of schedule": {"type a": n, "type b": n, "type c": n},  # Define the number of vehciles with each type of schedule in the fleet. (C is for Custom and you need to enter the characteristic in Custom Schedule)
    - "Type of vehicle": {"Renault": n, "Toyota": n},  # Renault or Toyota
    - "Company type": companytype.Custom, # Types of company: Distribution, LineHaul, CraftServWithGoods, CraftServWithoutGoods, Food, Mail, Building, Highdistance, Generalcargo, Nogoods, Custom
    - "Schedule name", Name of the schedule


## Citation
If you use , please cite:
<<<<<<< HEAD
Gil Ribeiro, C. (2025). eFleetScheduler V1.0.2 (V1.0.2). Zenodo. https://doi.org/10.5281/zenodo.16992966
=======
Gil Ribeiro, C. (2025). eFleetScheduler V1.0.2 (V1.0.2). Zenodo. https://doi.org/10.5281/zenodo.16992966
>>>>>>> 16b28e0e8bc6cd42d5d80933ddca1ce549d4ca34
fastapi-project-starter 1.2.0
Fastgen - FastAPI Project Generator & Scaffolder. Create production-ready FastAPI projects with modern features.
Requires Python: <4.0,>=3.8
Keywords: fastapi, template, generator, scaffold, boilerplate, typer, cli, python

# FastAPI Project Starter

A powerful CLI tool for generating production-ready FastAPI projects with modern features and best practices.

[![PyPI version](https://img.shields.io/pypi/v/fastapi-project-starter.svg)](https://pypi.org/project/fastapi-project-starter/)
[![Python Support](https://img.shields.io/pypi/pyversions/fastapi-project-starter.svg)](https://pypi.org/project/fastapi-project-starter/)
[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)

## ✨ Features

- **Database Support** - PostgreSQL + SQLAlchemy + Alembic migrations with async or sync support
- **Authentication** - JWT tokens + bcrypt + user management endpoints
- **Background Tasks** - Celery + Redis + task monitoring with Flower
- **Advanced Logging** - Loguru + structured logging + log rotation
- **Docker Ready** - Complete containerization with docker-compose setup
- **Modern Python** - Type hints, Pydantic v2, Python 3.8+ support

## Installation

```bash
  pip install fastapi-project-starter
```

## Quick Start

### Interactive Mode (Recommended)
```bash
  fastapi_generator new create my_test_app -i

```




## Usage

```bash
  fastapi_generator [COMMAND] [OPTIONS]

  Commands:
    new       Create a new FastAPI project
    version   Show current version

  Options:
    --help    Show help for the CLI or any subcommand

```



## After Generation

**Navigate and setup**:
   ```bash
      cd project_name
      make install
      make dev           # Build the docker containers
      make migrate       # Run initial migrations
   ```


**Access your API**:
   - API: http://localhost:8000
   - Docs: http://localhost:8000/docs
   - Flower: http://localhost:5555
   - Mailpit: http://localhost:8025
   - Traefik Dashboard: http://localhost:8080

## Contributing

Contributions are welcome! Please feel free to submit a Pull Request.

## License

This project is licensed under the MIT License.

---

**FastAPI Project Starter** - From zero to production-ready FastAPI in seconds!
rbf-lang 0.2.2
Reversible BitFuck (RBF) interpreter
Requires Python: >=3.9
Keywords: esolang, reversible, turing tarpits, interpreter

# rbf-lang

[![PyPI version](https://badge.fury.io/py/rbf-lang.svg)](https://pypi.org/project/rbf-lang/)
[![publish](https://github.com/MarcinKonowalczyk/rbf-lang/actions/workflows/publish.yml/badge.svg)](https://github.com/MarcinKonowalczyk/rbf-lang/actions/workflows/publish.yml)
[![Ruff](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ruff/main/assets/badge/v2.json)](https://github.com/astral-sh/ruff)
![Python versions](https://img.shields.io/badge/python-3.9%20~%203.14-blue)
[![Snapcraft](https://img.shields.io/badge/Snapcraft-e95420?logo=snapcraft&logoColor=fff)](#)

[Reversible BitFuck](https://esolangs.org/wiki/Reversible_Bitfuck) (RBF) is a [reversible Turing tarpit](https://cstheory.stackexchange.com/questions/22128/reversible-turing-tarpits). It is based on a tape of bits and has 5 commands:

 - `*` Toggle the current bit
 - `>` Shift the tape head right
 - `<` Shift the tape head left
 - `(` If the current bit is zero, jump past matching `)`
 - `)` If the current bit is zero, jump to just after matching `(`

Here is an example program operating on 3 bits. Bit 0 is the source bit (`x`), bit 1 is the target bit (`y`) and bit 2 is the temporary bit (`f`). Here the value of `x` is being moved to `y`.

```
# x=?, y=0, f=0
(>>*<<)        # set f if x is set
>>(            # if f is set
    <(>*<)*    # set y
    <*(>>*<<)  # unset x
>>)
<(>*<)         # if y is set, unset f
```

we can run the above program on an example tape (`100`) with rbf cli:

```sh
rbf run -t 100 "(>>*<<)>>(<(>*<)*<*(>>*<<)>>)<(>*<)"  # outputs 010
```

Since RBF is reversible, we can easily create a move left program:

```sh
rbf reverse "(>>*<<)>>(<(>*<)*<*(>>*<<)>>)<(>*<)"  # outputs (>*<)>(<<(>>*<<)*>*(>*<)>)<<(>>*<<)
```

## installation

RBF can be installed from source with

```sh
pip install .
```

or from pypi with

```sh
pip install rbf-lang
```


## links

_(as of yet uncategorised links to related topics. Will be sorted and expanded in the future)_

- https://en.wikipedia.org/wiki/Toffoli_gate
- https://arxiv.org/abs/1110.2574
- https://www.sciencedirect.com/science/article/abs/pii/016727899090185R?via%3Dihub
- http://weblog.raganwald.com/2004/10/beware-of-turing-tar-pit.html