semvec/pypi-packages huggingface dataset:
sbn 150
Since 4 March 2019

| **Information and Evidence Unit**
| **Office of the Prosecutor**
| **Post Office Box 19519**
| **2500 CM The Hague**
| **The Netherlands** 
|


Hello Office of the Prosecutor, 


i write you in the context of communications and claims under art.15 of 
the Rome Statute. i want to inform the prosecutor that the king of the 
netherlands and his government are commiting 3 of the 5 crimes defined 
in the Rome Statute. 

The dutch government has introduced three new forced care laws, the Wfz 
(wet forensische zorg) for criminals, the WvGGZ (Wet verplichte GGZ) for 
the disturbed and addicted and the Wzd (Wet zorg en dwang) for the 
handicapped.

Both the chamber suggesting these laws to the king and the king himself 
have been informed about the fact the the substances administered under 
these laws are proven to be poison.
 
There is proof the medication used in forced treatements in the 
netherlands are poison, see copies of the ECHA <`European Chemical Agency`>
website for:

(1) ``haldol``
(2) ``clozapine``
(3) ``zyprexa``
(4) ``abilify``

With the mass scale torture with poison the king of the netherlands and 
his chamber:

(1) kills
(2) does grave bodily and mental harm
(3) makes impotent

on the following victim groups here in the Netherlands:

(1) verslaafden (addicts)
(2) bejaarden (elderly)
(3) ggz patienten (psychiatric patients)
(4) criminelen (criminials)
(5) gehandicapten (handicapped)

Since the members of the chamber and the king were aware that these
medicine are poison at the time they voted for this law and the day the Wfz
law took effect (1-1-2019), i ask the prosecutor to prosecute the king for
making the commiting of the above mentioned crimes (killing, torture and
impotent making) possible.
nvidia-cutlass-dsl-libs-base 4.4.0
NVIDIA CUTLASS Python DSL
Requires Python: >=3.10

CUTLASS 4.x provides a Python native interfaces for writing high-performance CUDA kernels based on core CUTLASS and CuTe concepts without any performance compromises. This allows for a much smoother learning curve, orders of magnitude faster compile times, native integration with DL frameworks without writing glue code, and much more intuitive metaprogramming that does not require deep C++ expertise.

Overall we envision CUTLASS DSLs as a family of domain-specific languages (DSLs). With the release of 4.0, we are releasing the first of these in CuTe DSL. This is a low level programming model that is fully consistent with CuTe C++ abstractions — exposing core concepts such as layouts, tensors, hardware atoms, and full control over the hardware thread and data hierarchy.

CuTe DSL demonstrates optimal matrix multiply and other linear algebra operations
targeting the programmable, high-throughput Tensor Cores implemented by
NVIDIA's Ampere, Hopper, and Blackwell architectures.

We believe it will become an indispensable tool for students, researchers, and performance
engineers alike — flattening the learning curve of GPU programming, rapidly prototyping kernel
designs, and bringing optimized solutions into production.

CuTe DSL is currently in public beta and will graduate out of beta by end of summer 2025.

For more details please visit [CUTLASS Documentation](https://docs.nvidia.com/cutlass) or [CUTLASS Github](https://github.com/NVIDIA/cutlass/tree/main).
iflow-mcp_daobataotie-mssql-mcp 1.0.3
MSSQL MCP Server for database interaction and business intelligence
Requires Python: >=3.8

# MSSQL MCP Server

[English](/README_en.md) | [中文](/README_zh.md) 

## Overview

MSSQL MCP Server,  provides database interaction and business intelligence capabilities. This server enables running SQL queries, analyzing business data, and automatically generating business insight memos.  
Refer to the official website's SQLite for modifications to adapt to MSSQL

## Components

- `read_query`
   - Execute SELECT queries to read data from the database
- `write_query`
   - Execute INSERT, UPDATE, or DELETE queries
- `create_table`
   - Create new tables in the database
- `list_tables`
   - Get a list of all tables in the database
- `describe-table`
   - View schema information for a specific table
- `append_insight`
   - Add new business insights to the memo resource

## Demo
The database table is as follows. The column names are not standardized, and AI will match them on its own. Errors during SQL execution will self correct.

![Table](imgs/table.png)

The following is the demo.

![Demo](imgs/demo.gif)
   
## Operating environment

- `Python 3.x`
- `Packages`
   - pyodbc>=4.0.39
   - pydantic>=2.0.0
   - mcp>=0.1.0 
- `ODBC Driver 17 for SQL Server`

## Usage 

### Install packages

```bash
CD /d ~/mssql-mcp  
pip install -r requirements.txt  
```

### config

```bash
#with server.py same folder create config.json，add：    
{
    "database": {
        "driver": "ODBC Driver 17 for SQL Server",
        "server": "server ip",
        "database": "db name",
        "username": "username",
        "password": "password",
        "trusted_connection": false
    },
    "server": {
        "name": "mssql-manager",
        "version": "0.1.0"
    }
}
```

### Claude Desktop 、 Windsurf

```bash
# add to claude_desktop_config.json. Note：use your path  
{
    "mcpServers": {
        "mssql": {
            "command": "python",
            "args": [
                # your path，e.g.："C:\\mssql-mcp\\src\\server.py"
                "~/server.py"
            ]
        }
    }
}
```

### Cursor

```bash
# Add according to the following diagram Cursor MCP. Note：use your path  
```
![Cursor config](imgs/cursor_config.png)

Note：The new version of cursor has also been changed to JSON configuration, please refer to the previous section

### MCP Inspector

```bash
# Note：use your path  
npx -y @modelcontextprotocol/inspector python C:\\mssql-mcp\\src\\server.py
```
## Project Structure

```
mssql-mcp
├── .git
├── .gitignore
├── LICENSE
├── README.md
├── README_en.md
├── README_zh.md
├── imgs
│   ├── cursor_config.png
│   ├── table.png
│   └── demo.gif
├── requirements.txt
└── src
    ├── __init__.py
    └── server.py
```

## License

MIT License
nvidia-cutlass-dsl-libs-cu13 4.4.0
NVIDIA CUTLASS Python DSL
Requires Python: >=3.10

CUTLASS 4.x provides a Python native interfaces for writing high-performance CUDA kernels based on core CUTLASS and CuTe concepts without any performance compromises. This allows for a much smoother learning curve, orders of magnitude faster compile times, native integration with DL frameworks without writing glue code, and much more intuitive metaprogramming that does not require deep C++ expertise.

Overall we envision CUTLASS DSLs as a family of domain-specific languages (DSLs). With the release of 4.0, we are releasing the first of these in CuTe DSL. This is a low level programming model that is fully consistent with CuTe C++ abstractions — exposing core concepts such as layouts, tensors, hardware atoms, and full control over the hardware thread and data hierarchy.  

CuTe DSL demonstrates optimal matrix multiply and other linear algebra operations
targeting the programmable, high-throughput Tensor Cores implemented by
NVIDIA's Ampere, Hopper, and Blackwell architectures.  

We believe it will become an indispensable tool for students, researchers, and performance
engineers alike — flattening the learning curve of GPU programming, rapidly prototyping kernel
designs, and bringing optimized solutions into production.  

CuTe DSL is currently in public beta and will graduate out of beta by end of summer 2025.

For more details please visit [CUTLASS Documentation](https://docs.nvidia.com/cutlass) or [CUTLASS Github](https://github.com/NVIDIA/cutlass/tree/main).
py-runner-base 1.0.0
runs one or more steps in order or by cli
Requires Python: >=3.9
Keywords: runner, utilities

* website: [Website](https://arrizza.com/py-runner-base.html)
* installation: [Common Setup](https://arrizza.com/setup-common.html)

## Summary

This project is a base class for running various commands in python from the command line.

see ```sample/toolbox_app.py``` for an example use.

see ```doc/api.md``` for the API available.

## how to run

Don't specify a command gives you help.
Note that you can use check() in toolbox_runner.py or run() in toolbox_app.py to
specify a default command.

```bash
./doit 
WARN no command chosen, nothing to do
     py-runner-base: v0.1.0
     Choose one of these:
        task1               : run task1
        task2a              : run task2 step-a
        task2b              : run task2 step-b
        task3               : run task3
        task4               : run task4
```

Note: that there are several sorting orders available, see property ```sort_order``` in base_runner.py or
cmd_map.py.

* Add an argument ```arg1```:

```text
$ ./doit task1 arg1
==== doit: starting...
     running Task1 args:['arg1']
     doit: run_it rc=0
```

* Run a command "task1" that has no prerequisites:

```bash
./doit task1
==== doit: starting...
     running Task1 args:[]
     doit: run_it rc=0
```

* Run a command "task2b" that has a prerequisite:

```bash
./doit task2b
==== doit: starting...
     running Task2 step-a
     running Task2 step-b
     doit: run_it rc=0
```

## how to add commands

See the ```sample/taskxx.py``` files for example tasks.
Note ```register()``` functions that allow you to specify command names for any tasks
you want to add.

```text
    # --------------------
    def register(self, runner):
        self._runner = runner
        self._runner.add_cmd('task2a', self._run_step_a, 'run task2 step-a')
        self._runner.add_cmd('task2b', self._run_step_b, 'run task2 step-b', prereqs=['task2a'])
```
nvidia-cutlass-dsl 4.4.0
NVIDIA CUTLASS Python DSL
Requires Python: >=3.10

CUTLASS 4.x provides a Python native interfaces for writing high-performance CUDA kernels based on core CUTLASS and CuTe concepts without any performance compromises. This allows for a much smoother learning curve, orders of magnitude faster compile times, native integration with DL frameworks without writing glue code, and much more intuitive metaprogramming that does not require deep C++ expertise.

Overall we envision CUTLASS DSLs as a family of domain-specific languages (DSLs). With the release of 4.0, we are releasing the first of these in CuTe DSL. This is a low level programming model that is fully consistent with CuTe C++ abstractions — exposing core concepts such as layouts, tensors, hardware atoms, and full control over the hardware thread and data hierarchy.  

CuTe DSL demonstrates optimal matrix multiply and other linear algebra operations
targeting the programmable, high-throughput Tensor Cores implemented by
NVIDIA's Ampere, Hopper, and Blackwell architectures.  

We believe it will become an indispensable tool for students, researchers, and performance
engineers alike — flattening the learning curve of GPU programming, rapidly prototyping kernel
designs, and bringing optimized solutions into production.  

CuTe DSL is currently in public beta and will graduate out of beta by end of summer 2025.

For more details please visit [CUTLASS Documentation](https://docs.nvidia.com/cutlass) or [CUTLASS Github](https://github.com/NVIDIA/cutlass/tree/main).
dc-u2-driver 0.1.0
A lightweight Khmer greeting utility for Python

# DC U2 Driver

**Credit:** Original development by **Dai Chao Online**

DC U2 Driver is a lightweight Python package for automating Android devices using **uiautomator2**.  
It’s designed for developers who want fast device interactions, robust element handling, and simple APIs without extra complexity.

## Features

- Connect to Android devices via device ID  
- Interact with UI elements using multiple locator types  
- Handle clicks, long clicks, and text input  
- Retrieve element attributes safely  
- Filter English text and skip unwanted UI elements  
- Retry clicks and wait for elements with customizable timing  
- Supports Python 3.10+  

## Installation

Install using pip:

```bash
pip install dc-u2-driver