semvec/pypi-packages huggingface dataset:
digitalmarketplace-developer-tools 2.0.0
Common developer tools for Digital Marketplace repos
Requires Python: <3.15,>=3.9

# Digital Marketplace developer tools

Common developer tooling for Digital Marketplace repos.

## Quickstart

Install [the digitalmarketplace-developer-tools package from PyPI][package] and
run Invoke in a Digital Marketplace repo to see what tasks are available:

```
$ pip install digitalmarketplace-developer-tools
$ invoke --list
```

## Stuff in this repo

### Invoke tasks

Developers on the Digital Marketplace need to be able to easily set-up a
developer environment for a repo, so they can quickly start making changes to
the code.

Traditionally this need has been met with `make`, however on the Digital
Marketplace we are starting to use [Invoke][pyinvoke] instead.

Invoke lets us write tasks once and use them for multiple repos. Being written
in Python, we can create a library of tasks and publish them on PyPI for reuse.
The [package for this repo][package] includes these tasks.

To start using the tasks in a repo, add a `tasks.py` file and import the
collection of tasks appropriate for the repo. For instance, for a frontend app:

```
# tasks.py
from dmdevtools.invoke_tasks import frontend_app_tasks as ns
```

The `as ns` part is needed so that the `invoke` command line tool sees the
imported tasks, read the [Invoke documentation on collections and
namespaces][1] for more details on how this works.

For backwards-compatibility, `make` can still be used for a repo. Just copy the
[`Makefile` from this repo](Makefile) (or just the `%` goal), and any
unrecognised goals will be sent to `invoke`.

[1]: http://docs.pyinvoke.org/en/stable/concepts/namespaces.html#starting-out

## Pre-commit hooks

This project has a [pre-commit hook][pre-commit hook] to do some general file checks and check the `pyproject.toml`.
Follow the [Quick start][pre-commit quick start] to see how to set this up in your local checkout of this project.

## Licence

Unless stated otherwise this codebase is released under [the MIT
License][licence]. This covers both the codebase and any sample code in the
documentation.

The documentation is [&copy; Crown copyright][copyright] and available under
the terms of the [Open Government 3.0][ogl] licence.

[licence]: LICENCE
[copyright]: http://www.nationalarchives.gov.uk/information-management/re-using-public-sector-information/uk-government-licensing-framework/crown-copyright/
[ogl]: http://www.nationalarchives.gov.uk/doc/open-government-licence/version/3/

[package]: https://pypi.org/project/digitalmarketplace-developer-tools
[pyinvoke]: pyinvoke.org

[pre-commit hook]: https://pre-commit.com/
[pre-commit quick start]: https://pre-commit.com/#quick-start
dtnclient 0.2
Python client for dtn7-go
Requires Python: >=3.12
Keywords: dtn bundle_protocol

[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)

# Easy, straightforward interaction with [dtnd](https://github.com/dtn7/dtn7-go)

Interact with the [UNIX Application agent](https://github.com/dtn7/dtn7-go/tree/main/pkg/application_agent/unix_agent) of `dtn7`.

This package can be used as either a library or directly as a cli client.

Then main entrypoint for library usage are the functions in [client.py](dtnclient/client.py).

For cli usage, see `dtnclient --help`.
vibrary 0.0.1
Universal Content Registry for AI Applications - unified storage and semantic search for documents, posts, media
Requires Python: >=3.10
Keywords: ai, content-registry, document-management, hybrid-search, knowledge-base, qdrant, semantic-search, vector-search

# vibrary

> Universal Content Registry for AI Applications

## Coming Soon

**vibrary** is a unified system for storing and searching content of any type with semantic search capabilities.

### Planned Features

- **Entity Registry** - Unified metadata for documents, posts, audio, video, and other media
- **Information Blocks** - Searchable content chunks with graph relations
- **3-Layer Hybrid Search** - Dense embeddings + vocabulary matching + sparse vectors
- **Hierarchical Relations** - parent/child, avatar/main, revisions tracking
- **Source Tracking** - Origin, conversions, and format history

### Use Cases

- Knowledge bases with mixed content types
- Document management with semantic search
- Media libraries with transcription/avatar support
- Legal document versioning and comparison

## Installation (future)

```bash
pip install vibrary
```

## Links

- GitHub: https://github.com/LifeAiTools/vibrary
- PyPI: https://pypi.org/project/vibrary/

## License

Apache-2.0
topsis-sachingoyal-102303557 1.0.0
TOPSIS decision method Python package
Requires Python: >=3.7

# TOPSIS Implementation (Sachin Goyal)

Simple TOPSIS (Technique for Order Preference by Similarity to Ideal Solution) implementation in Python.

Project structure
- data.csv                 (example input)
- setup.py                 (packaging / install - optional)
- topsis/                  (package)
  - __init__.py
  - topsis.py              (main implementation and CLI)

Summary
- Reads a CSV where the first column is an identifier (name) and the remaining columns are numeric criteria.
- Computes TOPSIS scores and ranks using provided weights and impacts.
- Writes an output CSV that includes the original data plus `Topsis Score` and `Rank` columns.

Prerequisites
- Python 3.6+
- pandas and numpy

Quick install (no virtualenv):

Open a terminal and run:

    python -m pip install pandas numpy

Or create a virtual environment first, then install the same packages.

Usage

There are two simple ways to run the script.

1) Run as a module (from project root):

    python -m topsis.topsis <InputFile> "<Weights>" "<Impacts>" <OutputFile>

2) Run the script file directly:

    python topsis\topsis.py <InputFile> "<Weights>" "<Impacts>" <OutputFile>

Arguments
- <InputFile>: path to the input CSV file.
- <Weights>: comma-separated numeric weights for each criterion (e.g. "1,1,1,1").
- <Impacts>: comma-separated + or - for each criterion (e.g. "+,+,-, +").
- <OutputFile>: path for the output CSV.

Input CSV format
- Must have at least 3 columns (first column: identifier; at least two criteria columns).
- All columns from the 2nd to last must contain numeric values.
- Example:

    Name,Cost,Performance,Reliability
    A,250,8,9
    B,200,7,8

Example

    python -m topsis.topsis data.csv "1,1,1" "+,+,-" result.csv

This will produce `result.csv` with two extra columns:
- `Topsis Score` (higher is better)
- `Rank` (1 = best)

Common errors and messages
- "Input file not found": the specified input file path doesn't exist.
- "Unable to read input file": input file not a valid CSV.
- "Input file must contain at least 3 columns": CSV missing required columns.
- "All columns from 2nd to last must contain numeric values": non-numeric values in criteria columns.
- "Number of weights must be equal to number of criteria": mismatch between provided weights and criteria count.
- "Number of impacts must be equal to number of criteria": mismatch between provided impacts and criteria count.
- "Impacts must be either + or -": impacts should be "+" or "-" only.
- "Weights must be numeric": weights should be numbers.

Notes
- Weights are normalized implicitly by the algorithm's normalization step.
- The implementation uses Euclidean normalization.

Author
- Sachin Goyal (student project)

License
- Use or adapt as needed for learning or coursework.
unicef-security 1.9.2
Provides Basic UNICEF User model and integration with Azure

# UNICEF-Security

[![Coverage Development](https://codecov.io/gh/unicef/unicef-security/branch/develop/graph/badge.svg?token=sytM1cd8Zj)](https://codecov.io/gh/unicef/unicef-security)
[![Coverage Stable](https://codecov.io/gh/unicef/unicef-security/branch/master/graph/badge.svg?token=sytM1cd8Zj)](https://codecov.io/gh/unicef/unicef-security)
[![Issue tracker](https://img.shields.io/github/issues/unicef/unicef-security.svg)](https://github.com/unicef/unicef-security/issues)

## Installation

```bash
pip install unicef-security
```

## Setup

Add `unicef_security` to `INSTALLED_APPS` in settings:

```python
INSTALLED_APPS = [
    'admin_extra_urls',
    'unicef_security',
]
```

## Contributing

### Environment Setup

To configure the development environment:

```bash
$ python manage.py upgrade --all
```

### Coding Standards

To run checks on the code to ensure code is in compliance:

```bash
$ ruff check
$ ruff format
```

### Testing

Testing is important and tests are located in `tests/` directory and can be run with:

```bash
$ uv run pytest test
```

Coverage report is viewable in `build/coverage` directory, and can be generated with:

```bash
$ pytest --cov=unicef_security --cov-report=html
```
pyPhasesRecordloaderDomino 0.1.3
Adds a record loaders to the pyPhases package
Requires Python: >=3.5

# Extension for pyPhasesRecordloader



## Usage

In a phase you can access the data through the `RecordLoader`:

Add the plugins and config values to your project.yaml:

```yaml
name: DominoProject
plugins:
  - pyPhasesML
  - pyPhasesRecordloaderDomino
  - pyPhasesRecordloader

phases:
  - name: MyPhase

config:
  domino-path: C:/datasets/recordings

```

In a phase (`phases/MyPhase.py`) you can access the records using the `RecordLoader`:

```python
from pyPhasesRecordloader import RecordLoader
from pyPhases import Phase

class MyPhase(Phase):
    def run(self):
      recordIds = recordLoader.getRecordList()
      for recordId in recordIds:
        record = recordLoader.getRecord(recordId)
```

Run your project with `python -m phases run MyPhase`.


The RecordLoader requires EDF files (using the EDF export), annotations (using the annotation export) and ERG files from the raw Domino data. An example of our setup can be found at https://gitlab.com/sleep-is-all-you-need/dominodatasetcreator.
depsgraph 0.1.4
Visualize internal Python import dependencies
Requires Python: >=3.11

depsgraph is a minimal command-line tool that shows which Python modules a single file depends on *within your project*. It ignores stdlib and third-party imports by default, so you see only your own code’s coupling.

### Features
- Static analysis via AST (fast, no imports executed)
- ASCII tree printed to stdout
- Mermaid mindmap generated as `.mmd` and self-contained `.html`
- Configurable recursion depth and ignore patterns
- Detects import cycles and marks them

### Install

pip install depsgraph

### Usage

depsgraph path/to/file.py --project-dir /path/to/project

Example:

$ depsgraph src/handlers/api.py --project-dir .
src/handlers/api.py
+-- src/models/user.py
+-- src/utils/auth.py
|   +-- src/config.py
+-- src/db/conn.py
    +-- src/config.py

The command also creates `deps_graph.html` in the project directory; open it in a browser to view an interactive Mermaid mindmap.

### Options
- --project-dir: root of the project to scan (default ".")
- --max-depth: limit graph depth (default 50)
- --show-missing: list unresolved imports (stdlib, missing files)
- --no-mermaid: skip Mermaid file generation
- --ignored-dir: repeatable, e.g. `--ignored-dir generated`

### Requirements
Python 3.9+

### License
MIT