semvec/pypi-packages huggingface dataset:
pipenv-uv 0.0.6
Patch pipenv to use uv for lock and sync operations.
Requires Python: >=3.10
Keywords: pipenv, uv

# pipenv-uv

[![PyPI - Version](https://img.shields.io/pypi/v/pipenv-uv.svg)](https://pypi.org/project/pipenv-uv)
[![PyPI - Python Version](https://img.shields.io/pypi/pyversions/pipenv-uv.svg)](https://pypi.org/project/pipenv-uv)
[![pre-commit.ci status](https://results.pre-commit.ci/badge/github/FlavioAmurrioCS/pipenv-uv/main.svg)](https://results.pre-commit.ci/latest/github/FlavioAmurrioCS/pipenv-uv/main)

Patch pipenv to use uv for lock and sync operations.

-----

## Table of Contents

- [pipenv-uv](#pipenv-uv)
  - [Table of Contents](#table-of-contents)
  - [Installation](#installation)
  - [Usage](#usage)
  - [Environmental Variables](#environmental-variables)
  - [TODO](#todo)
  - [License](#license)

## Installation

With pipx:

```bash
pipx install pipenv
pipx inject pipenv pipenv-uv
```

With uv:

```bash
uv tool install pipenv --with pipenv-uv --force-reinstall
```

Inject directly into pipenv(incase you install pipenv with something like brew):

```bash
"$(head -n1 "$(which pipenv)" | sed 's|#!||g')" -m pip install pipenv-uv
```

## Usage

Just use pipenv as normal :D

## Environmental Variables
- `PIPENV_UV_DISABLE_RESOLVE_PATCH` - Disable the patch for the resolve/lock command
- `PIPENV_UV_DISABLE_INSTALL_PATCH` - Disable the patch for install command
- `PIPENV_UV_DISABLE_ALL_PATCHES` - Disable all patches
- `PIPENV_UV_VERBOSE` - Enable verbose output

## TODO
- [ ] Handle conflicts for main packages and dev packages
- [x] Use uv for sync/install as well
- [ ] Add test

## License

`pipenv-uv` is distributed under the terms of the [MIT](https://spdx.org/licenses/MIT.html) license.
topsis_harshit_102303276 0.1.0
Implementation of the TOPSIS Algorithm
Requires Python: >=3.13

# TOPSIS-Harshit-102303276

A Python package to implement the **Technique for Order of Preference by Similarity to Ideal Solution (TOPSIS)**. This command-line tool takes a dataset of alternatives and criteria, applies weights and impacts, and calculates a ranking score for each alternative.


## Installation

You can install this package via `pip`:

```bash
pip install topsis-harshit-102303276
```

## Usage

The package can be used through the command line. It requires an input CSV or Excel file containing your data, a string of weights, a string of impacts, and the name of the output file.

### Command Syntax

```bash
topsis <InputDataFile> <Weights> <Impacts> <ResultFileName>
```

### Arguments

1. **InputDataFile**: Path to the `.csv` or `.xlsx` file.
   - The file must contain **3 or more columns**.
   - **First column**: Object/Model Name (e.g., M1, M2, M3). This column is not used in calculations but is preserved in the output.
   - **Remaining columns**: Numeric values representing the criteria for each object.

2. **Weights**: Comma-separated numbers indicating the importance of each criterion (e.g., `"1,1,1,1"`).
3. **Impacts**: Comma-separated signs (`+` or `-`) indicating the desired direction of the criterion.
   - `+`: Higher value is better (Profit).
   - `-`: Lower value is better (Cost).

4. **ResultFileName**: Name of the output CSV file where results will be saved.

## Example

Let's assume we want to rank 5 different mobile phone models based on 4 criteria: **Price**, **Storage**, **Camera**, and **Looks**.

### 1. Input Data (`data.csv`)

| Model | Price | Storage | Camera | Looks |
| ----- | ----- | ------- | ------ | ----- |
| M1    | 250   | 16      | 12     | 5     |
| M2    | 200   | 16      | 8      | 3     |
| M3    | 300   | 32      | 16     | 4     |
| M4    | 275   | 32      | 8      | 4     |
| M5    | 225   | 16      | 16     | 2     |

- **Criteria Analysis**:
- **Price**: Lower is better (`-` impact).
- **Storage**: Higher is better (`+` impact).
- **Camera**: Higher is better (`+` impact).
- **Looks**: Higher is better (`+` impact).

### 2. Execution

Run the following command in your terminal:

```bash
topsis data.csv "1,1,1,1" "-,+,+,+" result.csv

```

- **Weights**: `1,1,1,1` (All criteria are equally important).
- **Impacts**: `-,+,+,+` (Price is negative impact, others are positive).

### 3. Output Data (`result.csv`)

The tool generates a new file `result.csv` containing the original data with two additional columns: **Topsis Score** and **Rank**.

| Model | Price | Storage | Camera | Looks | Topsis Score | Rank |
| ----- | ----- | ------- | ------ | ----- | ------------ | ---- |
| M1    | 250   | 16      | 12     | 5     | 0.534277     | 3    |
| M2    | 200   | 16      | 8      | 3     | 0.308368     | 5    |
| M3    | 300   | 32      | 16     | 4     | 0.691632     | 1    |
| M4    | 275   | 32      | 8      | 4     | 0.534737     | 2    |
| M5    | 225   | 16      | 16     | 2     | 0.492650     | 4    |
dbt-to-junit 0.2.0
Convert dbt's target/run_results.json into a JUnit XML report so Azure DevOps (ADO) can display dbt test results in the Tests tab.
Requires Python: >=3.8

# dbt to JUnit XML

Convert dbt's `target/run_results.json` into a JUnit XML report so Azure DevOps (ADO) can display dbt test results in the Tests tab.

This tool is designed for CI: it reads the run results produced by `dbt build`, generates a single JUnit report, and writes it to a file that can be published by ADO.

## What it reads

- **Input**: dbt `run_results.json` (typically `target/run_results.json`)
- **Source of truth**: the `results` list inside that file
- **Filtering**: by default, only dbt tests are included (`unique_id` starts with `test.`)

## What it writes

- **Output**: a JUnit XML file (default: `dbt-junit.xml`)
- **Structure**: one `<testsuite>` containing one `<testcase>` per dbt test

## Install / run (local)

If you're using this repo with `uv`:

```bash
uv sync
uv run dbt-junit-xml --input target/run_results.json --output dbt-junit.xml
```

You can also run it directly with Python:

```bash
python -m src.main --input target/run_results.json --output dbt-junit.xml
```

## CLI options

- `--input`: path to `run_results.json` (default: `target/run_results.json`)
- `--output`: output XML path (default: `dbt-junit.xml`)
- `--log-level`: `DEBUG|INFO|WARNING|ERROR` (default: `INFO`)
- `--include-models`: include non-test nodes as testcases (default: off)

## Help

You can also run the following command to get some help in the terminal:

```bash
uv run dbt-junit-xml --help
```

or

```bash
python -m src.main --help
```

Response:

```bash
usage: dbt-junit-xml [-h] [--input INPUT] [--output OUTPUT] [--include-models] [--log-level LOG_LEVEL]

Convert dbt run_results.json to JUnit XML.

options:
  -h, --help            show this help message and exit
  --input INPUT         Path to dbt run_results.json (default: target/run_results.json)
  --output OUTPUT       Path to write JUnit XML (default: dbt-junit.xml)
  --include-models      Include model results as testcases (default: only dbt tests).
  --log-level LOG_LEVEL
                        Logging level (DEBUG, INFO, WARNING, ERROR). Default: INFO
```

## Exit codes

- **0**: report generated and no failing dbt tests
- **1**: report generated and at least one dbt test failed/errored
- **2**: could not generate report (missing file, invalid JSON, unexpected format, etc.)

## Azure DevOps pipeline example

Run dbt (which produces `target/run_results.json`), generate the JUnit XML, then publish it:

```yaml
- script: |
    dbt build
    dbt-junit-xml --input target/run_results.json --output dbt-junit.xml
  displayName: "Run dbt and generate JUnit report"

- task: PublishTestResults@2
  displayName: "Publish dbt test results"
  inputs:
    testResultsFormat: "JUnit"
    testResultsFiles: "dbt-junit.xml"
    failTaskOnFailedTests: true
```

## Notes / tips

- If your pipeline working directory is not the dbt project root, pass an explicit `--input` path.
- If you only want dbt tests in ADO, do not pass `--include-models` (default behavior already filters to tests).