semvec/pypi-packages huggingface dataset:
uv2compdb 0.5.1
Generate Compilation Database by parse Keil µVision project
Requires Python: >=3.8
Keywords: keil, MDK, µVision, clangd, Compilation Database, compiled_commands.json

# uv2compdb

Generate [Compilation Database] by parse Keil µVision project.

## Features

+ Parse strategy (dep/build_log -> XML)
+ Extract toolchain predefined macros with `-p` option
+ VariousControls hierarchical merge (Target -> Group -> File)

## Installation

```sh
pip install uv2compdb
```

## Usage

### Basic Usage

Generate `compile_commands.json` in the current directory for the first target if the project has multiple targets.

```sh
uv2compdb /path/to/project
```

### Specify target and output

Generate `compile_commands.json` for a specific target and output

```sh
uv2compdb /path/to/project -t target -o /path/to/compile_commands.json
```

### Help

```sh
usage: uv2compdb [-h] [-v] [-a ARGUMENTS] [-b] [-t TARGET] [-o OUTPUT] [-p] project

Generate compile_commands.json by parse Keil µVision project

positional arguments:
  project               path to .uvproj[x] file

optional arguments:
  -h, --help            show this help message and exit
  -v, --version         show version and exit
  -a ARGUMENTS, --arguments ARGUMENTS
                        add extra arguments
  -b, --build           try to build while dep/build_log files don't not exist
  -t TARGET, --target TARGET
                        target name
  -o OUTPUT, --output OUTPUT
                        output dir/file path (default: compile_commands.json)
  -p, --predefined      try to add predefined macros
```

## Limit

+ [x] Not parsed `"Options" -> "C/C++" -> "Language / Code Generation"`
+ [x] Not parsed `"Options" -> "ASM"`, so Asm file use same options with C file
+ [x] Can't parse **RTE** components
+ [x] Can't add toolchain predefined macros and include path
+ [ ] The support for C51 / ARMCC (AC5) not well
  + need config `.clangd` manually

## [Clangd]

[.clangd config]

```yaml
CompileFlags:
  CompilationDatabase: /path/to/compile-commands-dir
  Compiler: arm-none-eabi-gcc # use arm-neon-eabi-gcc instead of armcc
  Add:
    - -fdeclspec  # fix '__declspec' if use arm-none-eabi-gcc instead of armcc

Diagnostics:
  UnusedIncludes: None  # Strict(default), None
  # Suppress:
  #   - no_member
  #   - no_member_suggest
  #   - no_template
  #   - undeclared_var_use
```

## References

+ [keil2clangd]
+ [uvConvertor]
+ [a3750/uvconvertor]

[Compilation Database]: <https://clang.llvm.org/docs/JSONCompilationDatabase.html>
[Clangd]: <https://clangd.llvm.org/>
[.clangd config]: <https://clangd.llvm.org/config>
[keil2clangd]: <https://github.com/huiyi-li/keil2clangd>
[uvConvertor]: <https://github.com/vankubo/uvConvertor>
[a3750/uvconvertor]: <https://github.com/a3750/uvconvertor>
tonutils 2.0.1b8
Tonutils is a high-level, object-oriented Python library designed to facilitate seamless interactions with the TON blockchain.
Requires Python: <3.15,>=3.10
Keywords: AsyncIO, TON, TON blockchain, The Open Network, blockchain, crypto, smart contracts

# 📦 Tonutils 2.0 [BETA]

[![TON](https://img.shields.io/badge/TON-grey?logo=TON&logoColor=40AEF0)](https://ton.org)
![Python Versions](https://img.shields.io/badge/Python-3.10%20--%203.14-black?color=FFE873&labelColor=3776AB)
[![PyPI](https://img.shields.io/badge/pypi-2.0.1b2-FFE873?labelColor=3776AB)](https://pypi.org/project/tonutils/2.0.1b2/)
[![License](https://img.shields.io/github/license/nessshon/tonutils)](LICENSE)

![Image](assets/banner.png)

![Downloads](https://pepy.tech/badge/tonutils)
![Downloads](https://pepy.tech/badge/tonutils/month)
![Downloads](https://pepy.tech/badge/tonutils/week)

**Tonutils** is a high-level, object-oriented Python library designed to simplify interactions with the TON blockchain.
It seamlessly integrates several prominent services for working with TON:

**Native ADNL:**

* Built-in ADNL-TCP lite-server client.

**HTTP API:**

* [toncenter.com](https://toncenter.com/) – Fast and reliable HTTP API for The Open Network.
* [tonapi.io](https://tonapi.io/) – REST API to the TON blockchain explorer.
* [chainstack](https://chainstack.com/) – Fast and Reliable Blockchain Infrastructure Provider.
* [tatum.io](https://tatum.io/) – RPCs and APIs powering Web3. Fast, reliable, affordable.
* [quicknode.com](https://www.quicknode.com/) – Low-latency HTTP API access to TON via global infrastructure.

By combining these services, `tonutils` provides a powerful and flexible toolset for developers, making it easier to
build on top of the TON ecosystem.

## Installation

```bash
pip install --pre tonutils
```

## Usage

Practical feature examples can be found in the **[examples](examples)** directory.

## Donations

Your contributions help me continue developing and improving this project!

**TON**: `UQCZq3_Vd21-4y4m7Wc-ej9NFOhh_qvdfAkAYAOHoQ__Ness`

## Support

Supported by [TON Society](https://github.com/ton-society/grants-and-bounties), Grants and Bounties program.\
With special thanks to [Igroman787](https://github.com/Igroman787) for the support.

## License

This repository is distributed under the [MIT License](LICENSE).
msight-core 2.0.0
A package for edge computing with msight edge nodes.
Requires Python: >=3.10

# MSight Core
MSight Core is an edge computing software system for connected and automated vehicle applications. It is designed to run on edge devices to integrate with traffic controllers, roadside sensors, road-side unit (RSU) and connected vehicles and infrastructure in real-time.


<!-- ## Installation and Run
### Docker Installation:
Do the following step to install the project on a edge device.

- [Install docker](https://docs.docker.com/engine/install/ubuntu/)
- [Finish docker post installation](#docker-post-installation)
- (Optional) install [Nvidia Container toolkit](https://docs.nvidia.com/datacenter/cloud-native/container-toolkit/latest/install-guide.html) if GPU is needed.
- write a `.env` file to specify information for the specific edge device, an example `.env` file is [here](.env-example).
- [Setup AWS Cloudwatch](docs/cloudwatch_logging.md)

### Local installation
#### Prerequisites:
- Python 3.10 or later
#### Local installation
For development installation:
```bash
pip install -e .
```

For normal installation:
```bash
pip install .
```
## Running:


## Docker post installation
For more details use [this tutorial](https://docs.docker.com/engine/install/linux-postinstall/). Do the following to complete docker configuration:
```bash
sudo groupadd docker
sudo usermod -aG docker $USER
newgrp docker
sudo systemctl enable docker.service
sudo systemctl enable containerd.service
```

## (Optional) Enable GPU runtime
If you need to run detection on the edge, you'll need to enable Nvidia docker runtime by installing Nvidia container toolkit to allow GPU runtime, follow official document [here](https://docs.nvidia.com/datacenter/cloud-native/container-toolkit/install-guide.html#installation-guide).

## Miscellaneous
- To deploy the testing system at MCity, here is an [example document](docs/mcity_edge_testing.md)
- In case you'll setup your own Kinesis stream, check [this document](docs/kinesis.md)

## Documentation

Install MkDocs and required plugins:
```bash
pip install mkdocs mkdocs-material mkdocs-gen-files mkdocs-literate-nav mkdocstrings mkdocstrings-python
```

Build and serve documentation:
```bash
# Serve on default port (8000)
mkdocs serve

# Serve on a specific port
mkdocs serve -a localhost:8080

# Serve on all interfaces with custom port
mkdocs serve -a 0.0.0.0:8080
```

Build static documentation:
```bash
mkdocs build
``` -->
saltpaper 0.0.6a0
A small game-engine/framework built on top of pygame
Requires Python: >=3.8

# saltPAPER

a game engine built on pygame-ce

## usage

TODO

## requirements

- Python >= 3.8
- pygame-ce >= 2.4.0
- numpy >= 1.24.0
- moderngl >= 5.8.0

## attribution
pygame-ce (LGPL license)