semvec/pypi-packages huggingface dataset:
telegrambotcli 0.5.2
A utility for quickly generating projects on aiogram 3
Requires Python: >=3.8
Keywords: aiogram, cli, generator, telegram, bot

## 🚀 TelegramBotCLI

A lightweight command-line utility for quickly generating professional project structures for **Aiogram 3** bots. Stop wasting time on boilerplate and start coding your logic instantly.

## ✨ Features

- **Standard & Advanced Templates:** Choose between a lightweight setup or a production-ready structure.
- **Pro Components:** Includes **Anti-flood Middleware** and **Admin Filters** out of the box.
- **Database Ready:** Pre-configured **SQLModel** (SQLite/PostgreSQL) integration.
- **Smart OS Detection:** Suggests the correct run command (`python` vs `python3`) for your system.
- **Automated Init:** Handles all `__init__.py` files automatically for clean imports.

## 📦 Installation

Install the tool directly from PyPI:

```bash
pip install telegrambotcli
```


## 🌞 How to Start

Open your terminal in the desired project folder and run:

bash

```
telegrambotcli
```

You will be prompted to choose a template:

1. **[Standard]** **: Basic bot with DB, Keyboards, and essential handlers.**
2. **[Advanced]** **: Includes Admin logic, Anti-flood protection, and advanced filtering.**

📂 Generated Project Structure

text

```
your_project/
├── app/
│   ├── database/
│   │   └── database.py    # SQLModel engine & User model
│   ├── filters/           # (Advanced) AdminFilter logic
│   ├── keyboards/
│   │   └── builders.py    # Reply & Inline keyboard templates
│   ├── middlewares/       # (Advanced) Anti-flood middleware
│   └── main.py            # Main Router (Help, Settings, Admin handlers)
├── bot.py                 # Main entry point (Dispatcher & Polling)
├── .env                   # Environment variables (Token, Admin ID)
└── .gitignore             # Pre-configured for Python & VSCode
```


## 🚀 Quick Start Guide

1. **Configure:** **Open the generated** `.env` **file and fill in your credentials:**
   env

   ```
   BOT_TOKEN="123456:ABC-DEF..."
   ADMIN_ID="987654321"
   ```
2. **Run:** **Launch your bot using the suggested command:**
   bash

   ```
   python bot.py  # or python3 bot.py
   ```

### 🛠 Handlers Included

The generated `app/main.py` automatically includes:

* `/start`, `/keyboard`, `/inline`
* **Text filters** **for "Help 🆘" and "Settings ⚙️" buttons.**
* **Admin check** **for the** `/admin` **command (in Advanced mode).**

## 🧑‍💻GitHub repository

[Sourse code](https://github.com/AnonimPython/telegrambotcli)
[PyPi page](https://pypi.org/project/telegrambotcli/)
dss-python-backend 0.15.0b3
Low-level Python bindings and native libs for DSS-Python, OpenDSSDirect.py and AltDSS-Python. Not intended for direct usage, see the high-level packages instead.
Requires Python: >=3.11

[![Builds](https://github.com/dss-extensions/dss_python_backend/actions/workflows/builds.yml/badge.svg)](https://github.com/dss-extensions/dss_python_backenbd/actions/workflows/builds.yml)
[![PyPI](https://img.shields.io/pypi/v/dss_python_backend)](https://pypi.org/project/dss-python-backend/)
<img alt="Supports Linux" src="https://img.shields.io/badge/Linux-FCC624?logo=linux&logoColor=black"> <img alt="Supports macOS" src="https://img.shields.io/badge/macOS-000000?logo=apple&logoColor=white"> <img alt="Supports Microsoft Windows" src="https://img.shields.io/badge/Windows-0078D6?logo=windows&logoColor=white">

# DSS-Python: Backend

`dss_python_backend` provides low-level bindings for an implementation of EPRI's OpenDSS, using [CFFI](https://cffi.readthedocs.io/) and our [DSS C-API library and headers](https://github.com/dss-extensions/dss_capi/). It contains the native libraries (and DLLs) required by DSS-Python. This is considered an implementation detail.

**This is not intended for direct usage, [see DSS-Python](https://github.com/dss-extensions/DSS-Python/), [OpenDSSDirect.py](https://github.com/dss-extensions/OpenDSSDirect.py/), and [AltDSS-Python](https://github.com/dss-extensions/AltDSS-Python/) instead!**

After several years integrated into DSS-Python, this package was created in April 2023 to make the maintenance easier. See https://github.com/dss-extensions/dss_python/issues/51

The Python package includes:
- FastDSS modules for AltDSS/DSS C-API
- CFFI modules for AltDSS/DSS C-API
- CFFI modules for user-models (only the code for generator user-models is being compiled nowadays)
- AltDSS/DSS C-API related libraries (AltDSS Engine, Oddie, Loader, etc.), DLLs, and headers

This module contains source-code licensed under BSD3 and LGPL3. See each file for SPDX comments.

Although this repository does not contain code from OpenDSS, the license is listed in `OPENDSS_LICENSE` for reference. The final packages do include software derived from OpenDSS code and other libraries, such as KLUSolveX and KLU (from SuiteSparse), both licensed under the LGPL. Since the files listed in this repository contain multiple licenses, SPDX identifiers are now included in the file headers.

*Note: this package might be renamed in the future to reflect the new developments.*
confusius 0.0.1a5
Python package for analysis and visualization of functional ultrasound imaging data.
Requires Python: <3.14,>=3.11

![PyPI version](https://img.shields.io/pypi/v/confusius)
![Python versions](https://img.shields.io/pypi/pyversions/confusius)
![License](https://img.shields.io/pypi/l/confusius)
[![DOI](https://zenodo.org/badge/1155356116.svg)](https://doi.org/10.5281/zenodo.18611124)
[![codecov](https://codecov.io/github/sdiebolt/confusius/graph/badge.svg?token=TL5AIRNSHS)](https://codecov.io/github/sdiebolt/confusius)

# ConfUSIus

> [!WARNING]
> ConfUSIus is currently in pre-alpha and under active development. The API is subject
> to change, and features may be incomplete or unstable.

ConfUSIus is a Python package for handling, visualization, preprocessing, and
statistical analysis of functional ultrasound imaging (fUSI) data.

## Installation

### 1. Setup a virtual environment

We recommend that you install ConfUSIus in a virtual environment to avoid dependency
conflicts with other Python packages. Using
[uv](https://docs.astral.sh/uv/guides/install-python/), you may create a new project
folder with a virtual environment as follows:

```bash
uv init new_project
```

If you already have a project folder, you may create a virtual environment as follows:

```bash
uv venv
```

### 2. Install ConfUSIus

ConfUSIus is available on PyPI. Install it using:

```bash
uv add confusius
```

Or with pip:

```bash
pip install confusius
```

To install the latest development version from GitHub:

```bash
uv add git+https://github.com/sdiebolt/confusius.git
```

### 3. Check installation

Check that ConfUSIus is correctly installed by opening a Python interpreter and
importing the package:

```python
import confusius
```

If no error is raised, you have installed ConfUSIus correctly.
grpcio-csm-observability 1.78.1
gRPC Python CSM observability package
Requires Python: >=3.9

gRPC Python CSM Observability
=============================

Package for gRPC Python CSM Observability.


Installation
------------

Currently gRPC Python CSM Observability is **only available for Linux**.

Installing From PyPI
~~~~~~~~~~~~~~~~~~~~

::

  $ pip install grpcio-csm-observability


Installing From Source
~~~~~~~~~~~~~~~~~~~~~~

::

  $ export REPO_ROOT=grpc  # REPO_ROOT can be any directory of your choice
  $ git clone -b RELEASE_TAG_HERE https://github.com/grpc/grpc $REPO_ROOT
  $ cd $REPO_ROOT
  $ git submodule update --init

  $ cd src/python/grpcio_csm_observability

  # For the next command do `sudo pip install` if you get permission-denied errors
  $ pip install .


Dependencies
------------
gRPC Python CSM Observability Depends on the following packages:

::

  grpcio
  grpcio-observability
  opentelemetry-sdk


Usage
-----

Example usage is similar to `the example here <https://github.com/grpc/grpc/tree/master/examples/python/observability>`_, instead of importing from ``grpc_observability``, you should import from ``grpc_csm_observability``:

.. code-block:: python

    import grpc_csm_observability
    
    csm_otel_plugin = grpc_csm_observability.CsmOpenTelemetryPlugin(
        meter_provider=provider
    )


We also provide several environment variables to help you optimize gRPC python observability for your particular use.

* Note: The term "Census" here is just for historical backwards compatibility reasons and does not imply any dependencies.

1. GRPC_PYTHON_CENSUS_EXPORT_BATCH_INTERVAL
    * This controls how frequently telemetry data collected within gRPC Core is sent to Python layer.
    * Default value is 0.5 (Seconds).

2. GRPC_PYTHON_CENSUS_MAX_EXPORT_BUFFER_SIZE
    * This controls the maximum number of telemetry data items that can be held in the buffer within gRPC Core before they are sent to Python.
    * Default value is 10,000.

3. GRPC_PYTHON_CENSUS_EXPORT_THRESHOLD
    * This setting acts as a trigger: When the buffer in gRPC Core reaches a certain percentage of its capacity, the telemetry data is sent to Python.
    * Default value is 0.7 (Which means buffer will start export when it's 70% full).

4. GRPC_PYTHON_CENSUS_EXPORT_THREAD_TIMEOUT
    * This controls the maximum time allowed for the exporting thread (responsible for sending data to Python) to complete.
    * Main thread will terminate the exporting thread after this timeout.
    * Default value is 10 (Seconds).
grpcio-admin 1.78.1
a collection of admin services
Requires Python: >=3.9

gRPC Python Admin Interface Package
===================================

Debugging gRPC library can be a complex task. There are many configurations and
internal states, which will affect the behavior of the library. This Python
package will be the collection of admin services that are exposing debug
information. Currently, it includes:

* Channel tracing metrics (grpcio-channelz)
* Client Status Discovery Service (grpcio-csds)

Here is a snippet to create an admin server on "localhost:50051":

    server = grpc.server(ThreadPoolExecutor())
    port = server.add_insecure_port('localhost:50051')
    grpc_admin.add_admin_servicers(self._server)
    server.start()

Welcome to explore the admin services with CLI tool "grpcdebug":
https://github.com/grpc-ecosystem/grpcdebug.

For any issues or suggestions, please send to
https://github.com/grpc/grpc/issues.
grpcio-csds 1.78.1
xDS configuration dump library
Requires Python: >=3.9

gRPC Python Client Status Discovery Service package
===================================================

CSDS is part of the Envoy xDS protocol:
https://www.envoyproxy.io/docs/envoy/latest/api-v3/service/status/v3/csds.proto.
It allows the gRPC application to programmatically expose the received traffic
configuration (xDS resources). Welcome to explore with CLI tool "grpcdebug":
https://github.com/grpc-ecosystem/grpcdebug.

For any issues or suggestions, please send to https://github.com/grpc/grpc/issues.
xds-protos 1.78.1
Generated Python code from envoyproxy/data-plane-api
Requires Python: >=3.9

Package "xds-protos" is a collection of ProtoBuf generated Python files for xDS protos (or the `data-plane-api <https://github.com/envoyproxy/data-plane-api>`_). You can find the source code of this project in `grpc/grpc <https://github.com/grpc/grpc>`_. For any question or suggestion, please post to https://github.com/grpc/grpc/issues.

Each generated Python file can be imported according to their proto package. For example, if we are trying to import a proto located at "envoy/service/status/v3/csds.proto", whose proto package is "package envoy.service.status.v3", then we can import it as:

::

  # Import the message definitions
  from envoy.service.status.v3 import csds_pb2
  # Import the gRPC service and stub
  from envoy.service.status.v3 import csds_pb2_grpc
photonforge 1.4.dev0
PhotonForge is a design tool that integrates with foundry PDKs to speed up the design, simulation, and verification cycle for optical components and systems.
Requires Python: >=3.10

# PhotonForge

PhotonForge is a design tool that integrates with foundry PDKs to speed up the
design, simulation, and verification cycle for optical components and systems. 


## Documentation

The online documentation can be found
[here](https://docs.flexcompute.com/projects/photonforge/).

Development docs:

- (docs/development.md)[docs/development.md]: local development setup.
- (docs/architecture.md)[docs/architecture.md]: general code structure and
  architecture.
- (docs/testing.md)[docs/testing.md]: testing infrastructure.
- (docs/deployment.md)[docs/deployment.md]: how to release a new version.
reflex-enterprise 0.5.4
Package containing the paid features for Reflex. [Pro/Team/Enterprise]
Requires Python: <4.0,>=3.10
Keywords: python, reflex, reflex-enterprise

# How to install reflex_enterprise.   

```bash
pip install reflex-enterprise
```

# How to use reflex enterprise.   
In the main file, instead of using `rx.App()` to create your app, use the following:


## In the main file
```python
import reflex_enterprise as rxe

...

rxe.App()

...
```

## In rxconfig.py
```python
import reflex_enterprise as rxe

config = rxe.Config(
    app_name="MyApp",
    ... # you can pass all rx.Config arguments as well as the one specific to rxe.Config
)
```

### Enterprise features

| Feature | Description | Minimum Tier (Cloud) | Minimum Tier (Self-hosted) |
| --- | --- | --- | --- |
| `show_built_with_reflex` | Toggle the "Built with Reflex" badge. | Pro | Team|
| `use_single_port` | Enable one-port by proxying from backend to frontend. | - | Team |
grpcio 1.78.1
HTTP/2-based RPC framework
Requires Python: >=3.9

gRPC Python
===========

Package for gRPC Python.


Installation
------------

gRPC Python is available for Linux, macOS, and Windows.

Installing From PyPI
~~~~~~~~~~~~~~~~~~~~

If you are installing locally...

::

  $ pip install grpcio

Else system wide (on Ubuntu)...

::

  $ sudo pip install grpcio

If you're on Windows make sure that you installed the :code:`pip.exe` component
when you installed Python (if not go back and install it!) then invoke:

::

  $ pip.exe install grpcio

Windows users may need to invoke :code:`pip.exe` from a command line ran as
administrator.

n.b. On Windows and on Mac OS X one *must* have a recent release of :code:`pip`
to retrieve the proper wheel from PyPI. Be sure to upgrade to the latest
version!

Installing From Source
~~~~~~~~~~~~~~~~~~~~~~

Building from source requires that you have the Python headers (usually a
package named :code:`python-dev`).

::

  $ export REPO_ROOT=grpc  # REPO_ROOT can be any directory of your choice
  $ git clone -b RELEASE_TAG_HERE https://github.com/grpc/grpc $REPO_ROOT
  $ cd $REPO_ROOT
  $ git submodule update --init

  # To include systemd socket-activation feature in the build,
  # first install the `libsystemd-dev` package, then :
  $ export GRPC_PYTHON_BUILD_WITH_SYSTEMD=1

  # For the next two commands do `sudo pip install` if you get permission-denied errors
  $ pip install -r requirements.txt
  $ GRPC_PYTHON_BUILD_WITH_CYTHON=1 pip install .

You cannot currently install Python from source on Windows. Things might work
out for you in MSYS2 (follow the Linux instructions), but it isn't officially
supported at the moment.

Troubleshooting
~~~~~~~~~~~~~~~

Help, I ...

* **... see the following error on some platforms**

  ::

    /tmp/pip-build-U8pSsr/cython/Cython/Plex/Scanners.c:4:20: fatal error: Python.h: No such file or directory
    #include "Python.h"
                    ^
    compilation terminated.

  You can fix it by installing `python-dev` package. i.e

  ::

    sudo apt-get install python-dev


Versioning
~~~~~~~~~~

gRPC Python is developed in a monorepo shared with implementations of gRPC in
other programming languages. While the minor versions are released in
lock-step with other languages in the repo (e.g. 1.63.0 is guaranteed to exist
for all languages), patch versions may be specific to only a single
language. For example, if 1.63.1 is a C++-specific patch, 1.63.1 may not be
uploaded to PyPi. As a result, it is __not__ a good assumption that the latest
patch for a given minor version on Github is also the latest patch for that
same minor version on PyPi.
femtodriver 2.0.2
Femtorun defines the runtime interface for Femtosense software
Requires Python: >=3.6

# Femtodriver

The Femtosense Femtodriver compiles models for the Femtosense SPU-001 and allows developers to run them in simulation as well as on hardware to obtain model outputs, along with key execution metrics.

See the documentation at [femtodriver.femtosense.ai](https://femtodriver.femtosense.ai) for more details.
osvcheck 1.0.0b1
Security vulnerability scanner for Python dependencies
Requires Python: >=3.11

# osvcheck

[![Python Tests](https://img.shields.io/github/actions/workflow/status/deeprave/osvcheck/python-test.yml?branch=main&label=tests)](https://github.com/deeprave/osvcheck/actions/workflows/python-test.yml)
[![PyPI version](https://img.shields.io/pypi/v/osvcheck)](https://pypi.org/project/osvcheck/)
[![Python versions](https://img.shields.io/pypi/pyversions/osvcheck)](https://pypi.org/project/osvcheck/)
[![Downloads](https://img.shields.io/pypi/dm/osvcheck)](https://pypi.org/project/osvcheck/)
[![Security](https://img.shields.io/github/actions/workflow/status/deeprave/osvcheck/codeql.yml?branch=main&label=security&logo=github)](https://github.com/deeprave/osvcheck/security/code-scanning)
[![Maintenance](https://img.shields.io/badge/maintained-yes-green.svg)](https://github.com/deeprave/osvcheck/graphs/commit-activity)

Lightweight vulnerability scanner for Python dependencies using the OSV database.

osvcheck scans your Python project's dependencies for known security vulnerabilities by querying the [OSV (Open Source Vulnerabilities)](https://osv.dev) database. It's designed for source-level checking during development and CI/CD pipelines.

**Key features:**
- Zero runtime dependencies (stdlib only)
- Auto-detects package manager (uv.lock, uv, or pip)
- Smart caching (12-48 hour TTL) minimizes API calls
- Distinguishes direct vs indirect vulnerabilities
- Optional rich integration for enhanced output (auto-detected if installed)

## Installation

Install via pip or uv, or add to your project's dev dependencies.

## Usage

```bash
# Scan current project
osvcheck

# Logging options
osvcheck -v              # Verbose (debug) output
osvcheck -q              # Quiet (warnings/errors only)
osvcheck --log-json      # JSON format logs
osvcheck --log-file FILE # Write logs to file

# Color control
osvcheck --color         # Force color output
osvcheck --no-color      # Disable color output
```

**Exit codes:**
- `0` - No vulnerabilities found
- `1` - Indirect dependency vulnerabilities only
- `2` - Direct dependency vulnerabilities found

**As a Pre-commit hook:**

Add to `.pre-commit-config.yaml`:
```yaml
- repo: https://github.com/deeprave/osvcheck
  rev: v1.0.0b1
  hooks:
    - id: osvcheck
```

**CI/CD integration:**
```bash
# Fail only on direct vulnerabilities
osvcheck || [ $? -eq 1 ]

# Fail on any vulnerabilities
osvcheck
```

## Features

- Scans Python dependencies for known security vulnerabilities
- Uses the OSV (Open Source Vulnerabilities) database
- Multi-environment support with auto-detection:
  - Uses `uv.lock` if present and up-to-date (fastest)
  - Falls back to `uv pip list` if uv is available
  - Falls back to `pip list` if pip is available
- Smart caching with 12-48 hour randomized TTL
- Distinguishes between direct and indirect dependency vulnerabilities
- Zero runtime dependencies (Python stdlib only)
- Optional rich integration for enhanced output (auto-detected if already installed)

## License

MIT License - See LICENSE file for details.