semvec/pypi-packages huggingface dataset:
onegeo-chat-client 2.1.3
RAG based chatbot client
Requires Python: >=3.10

# Onegeo chat project client


<!-- TABLE OF CONTENTS -->

# 📗 Table of Contents

- [📖 About the Project](#about-project)
- [💻 Getting Started](#getting-started)
- [👥 Authors](#authors)
- [📝 License](#license)


## 📖 [Onegeo Chat] <a name="about-project"></a>

Onegeo Chat is a RAG based chatbot.

It can harvest data from several sources.


## 💻 Getting Started <a name="getting-started"></a>

### Create and Publish OGC remote with Test PyPI

To create a version of the **onegeo-chat-client**, simply update the project **version** in the *pyproject.toml* file with <current_version>.

First, **create** the **package** with the following command:
```bash
cd onegeo_chat_client
python -m build
```
Then, **publish** it on **Test PyPI** with this command:
```bash
twine upload dist/*
```
You will need a Test PyPI account.
Take note that package file name can't be reused (desired behavior from Test PyPI).

### Install and Use OGC

Then, you can **install** the **client** with this command:
```bash
pip install onegeo-chat-client==<current_version>
```

As for the use, you can simply add this line to your files :
```py
from onegeo_chat_client import import Data, OnegeoChatClient
```
to use the classe defined in the client.

## 👥 Authors <a name="authors"></a>

👤 **Mathilde POMMIER**

- Mail: mpommier@neogeo.fr

👤 **Sébastien DA ROCHA**

- Mail: sdarocha@neogeo.fr

<p align="right">(<a href="#readme-top">back to top</a>)</p>


## 📝 License <a name="license"></a>

This project is [AGPL 3.0](../LICENSE) licensed.

<p align="right">(<a href="#readme-top">back to top</a>)</p>
baihu-logging 1.1.2
A logging bot which can log messages to Discord
Requires Python: >=3.6

# BaihuLogging

[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
[![Python Version](https://img.shields.io/badge/python-3.6+-blue.svg)](https://www.python.org/downloads/)

`Baihu Logging` is a lightweight and easy-to-use Python library, designed to help developers quickly send logs to Discord channels. Through Discord Webhook or Bot Token, you can monitor your application status in real-time.

---

## Features

- **Simple and Fast**: Just a few lines of code to complete the setup.
- **Clear Levels**: Support five standard log levels (DEBUG, INFO, WARNING, ERROR, CRITICAL), each level has its own color.
- **Formatted Output**: Automatically formats logs into Discord Embed messages with timestamp and footer.
- **Robust**: Built-in configuration validation and error handling.

---

## Installation

You can install `BaihuLogging` from the project directory via `pip`:

```bash
pip install .
```

Or you can directly place the `BaihuLogging` folder into your project.

---

## Quick Start

### 1. Get Discord Information
Before starting, make sure you have:
- **Bot Token**: Create a Bot in [Discord Developer Portal](https://discord.com/developers/applications) and get it.
- **Channel ID**: The ID of the channel you want to receive logs.

### 2. Basic Usage

```python
from BaihuLogging import DiscordLogger

# Initialize Logger
logger = DiscordLogger(
    token="YOUR_DISCORD_BOT_TOKEN",
    channel_id="YOUR_CHANNEL_ID"
)

# Send different level logs
logger.info("This is an info log")
logger.warning("This is a warning log!")
logger.error("This is an error log, please handle it quickly.")
```

---

## API Documentation

### `DiscordLogger(token, channel_id)`
Initialize the logger.
- `token` (str): Discord Bot Token.
- `channel_id` (str): The ID of the channel you want to receive logs.

### Support Methods
| Method | Log Level | Color | Description |
| :--- | :--- | :--- | :--- |
| `debug(msg)` | DEBUG | Gray | Used for debugging information in the development stage. |
| `info(msg)` | INFO | Blue | General running information. |
| `warning(msg)` | WARNING | Yellow | Warning of potential issues. |
| `error(msg)` | ERROR | Red | An error has occurred, affecting some functionality. |
| `critical(msg)` | CRITICAL | Purple | Serious system issues, need immediate intervention. |

---

## Development and Contribution

If you have any suggestions or find any bugs, please submit an issue or pull request.

### Developer
- **Author**: Baihu
- **GitHub**: [baihufox3210/Baihu-Logging](https://github.com/baihufox3210/Baihu-Logging)

---

## License

This project is licensed under the **MIT License**. For more details, please refer to the [LICENSE](file:///d:/project/Logging%20bot/LICENSE) file.
uvm-tb-gen 0.1.4
An automation tool that generates complete UVM testbench infrastructure with dynamic configuration for interfaces, agents, environments, and tests.
Requires Python: >=3.8
Keywords: UVM, SystemVerilog, Verification, VLSI, EDA, Testbench, Automation

# UVM Testbench Generator (uvm-tb-gen)

`uvm-tb-gen` is a Python-based command-line tool that automates the generation of complete UVM (Universal Verification Methodology) testbench architectures.  
It is designed to reduce repetitive boilerplate work and help verification engineers quickly bootstrap scalable and maintainable UVM environments.

# Features

- Interactive CLI-driven configuration
- Automatic generation of:
  - Interfaces
  - Transactions
  - Sequencers
  - Drivers
  - Monitors
  - Agents
  - Environment (env, scoreboard, subscriber)
  - Tests and sequences
  - Top-level module
- Supports multiple agents and interfaces
- Enforces consistent naming conventions
- Generates simulator-ready `files.f` and Makefile
- Works across Linux environments (bash, csh, HPC systems)

# Installation

```bash
pip install uvm-tb-gen
uv-jupyter-kernel 0.2.4
Add your description here
Requires Python: >=3.13

# uv-jupyter-kernel

Script to configure Jupyter kernels that use the [uv](https://github.com/astral-sh/uv) environment and dependency manager. It allows you to create isolated kernels for different Python versions, making it easier to use Jupyter with controlled and reproducible environments.

## Requirements
- Some Jupyter client (e.g., VSCode extension)
- [uv](https://github.com/astral-sh/uv) installed and available in the PATH

## Usage

```bash
uvx uv-jupyter-kernel --versions 3.13 3.12
```

By default, the script configures kernels for Python versions 3.13 and 3.12. You can specify other versions by passing them as arguments.

This will create (or update) kernel files at `~/.local/share/jupyter/kernels/uv-<version>/kernel.json`, allowing you to select the corresponding kernel for the desired Python version within Jupyter.

## What does the script do?
- Locates the `uv` executable on the system.
- For each specified Python version, creates a Jupyter kernel that:
  - Ephemerally installs `ipykernel` and starts the executor itself.
  - Ensures the `uv` PATH is available in the kernel environment.
  - Allows each notebook to run in an independent, ephemeral, and isolated environment.

## Advantages
- The only thing that needs to be available initially is uv.
- Ephemeral environments: each notebook has its own and can install new dependencies with `uv pip install`; when Jupyter is restarted, the environment is reset.
- No need to install Jupyter in the environment: less chance of dependency conflicts.
- Shared cache: each thing can be downloaded only once and then reused.

## Disadvantages
- Higher disk usage if your system does not support hardlinks (e.g., Termux on Android)
LscEncryption 0.0.2
加密方法（整合）
Requires Python: >=3.7

# 加密（整合）

## 加密方法
1. BinaryRecursiveMergeEncryption
2. ShuffleEncryption

### BinaryRecursiveMergeEncryption（二分归并加密）
* abcdefg => 
* aceg => 
* ae
* cg
* bdf =>
* bf
* d
* => aecgbfd

#### 调用方法
```
from LscEncryption import BRME

"""
BRME/binary_recursive_merge_encryption/brme
"""

print(brme("sdgj")) # => sgdj
```

### ShuffleEncryption（随机加密）
* abcdefg =>
* abcdegf
* abcdfeg
* abcdfge
* ……

#### 调用方法
```
from LscEncryption import SE

"""
se/SE/shuffle_encryption
"""

print(se("sdgj"))
```
jac-streamlit 0.0.6
Streamlit integration plugin for Jac programming language - enables running and visualizing Jac applications in Streamlit
Requires Python: >=3.12
Keywords: jac, jaclang, jaseci, streamlit, visualization, graph, object-spatial

# Jac-Streamlit Plugin

The `jac-streamlit` plugin provides seamless integration between the Jac programming language and Streamlit, enabling you to create interactive web applications and visualizations directly from Jac code.

## Features

- **Direct Execution**: Run Streamlit apps written in Jac with a single command
- **Graph Visualization**: Interactive and static visualization of Jac graph structures
- **Testing Framework**: Comprehensive testing support for Jac-Streamlit applications
- **Cross-Platform**: Works on Windows, macOS, and Linux

## Installation

```shell
pip install jac-streamlit
```

## Quick Start

### Running Jac Streamlit Applications

Execute a Streamlit app written in Jac:

```shell
jac streamlit app.jac
```

### Visualizing Jac Graphs

Visualize your Jac graph structures in an interactive web interface:

```shell
jac dot_view app.jac
```

This opens a Streamlit application with two visualization modes:

- **Interactive View**: Using streamlit-agraph for dynamic graph exploration
- **Static View**: Using pygraphviz for traditional graph rendering

## Testing

The plugin includes a testing framework compatible with Streamlit's testing methodology:

```python
from jaclang_streamlit import AppTest

# Create test instance from Jac file
app_test = AppTest.from_jac_file("path/to/your/app.jac")

# Run the app and perform tests
app = app_test.run()
assert len(app.exception) == 0
```

## Example

Here's a simple Jac Streamlit application:

```jac
import streamlit as st;

with entry {
    st.title("Hello Jac Streamlit!");
    name = st.text_input("Enter your name");
    if st.button("Greet") and name {
        st.success(f"Hello, {name}!");
    }
}
```

## Requirements

- Python 3.12+
- Jac programming language (jaclang)
- Streamlit 1.38+

## Documentation

For comprehensive documentation and examples, visit [jac-lang.org](https://jac-lang.org).

## License

MIT License - see the [LICENSE](https://github.com/jaseci-labs/jaseci/blob/main/LICENSE) file for details.