semvec/pypi-packages huggingface dataset:
silver-platter 0.5.48
Large scale VCS change management
Requires Python: >=3.9
Keywords: git bzr vcs github gitlab launchpad

# Python bindings for Silver-Platter

Silver-Platter makes it possible to contribute automatable changes to source
code in a version control system
([codemods](https://github.com/jelmer/awesome-codemods)).

It automatically creates a local checkout of a remote repository,
makes user-specified changes, publishes those changes on the remote hosting
site and then creates a pull request.

In addition to that, it can also perform basic maintenance on branches
that have been proposed for merging - such as restarting them if they
have conflicts due to upstream changes.

This package contains Python bindings for silver platter.

## Usage

The core class is the ``Workspace`` context manager, which exists in two forms:

* ``silver_platter.workspace.Workspace`` (for generic projects)
* ``silver_platter.debian.Workspace`` (for Debian packages)

An example, adding a new entry to a changelog file in the ``dulwich`` Debian
package and creating a merge proposal with that change:

```python

from silver_platter.debian import Workspace
import subprocess

with Workspace.from_apt_package(package="dulwich") as ws:
    subprocess.check_call(['dch', 'some change'], cwd=ws.path)
    ws.commit()  # Behaves like debcommit
    ws.publish(mode='propose')
```
pt-loop 0.1.0
Local Outlier Probabilities (LoOP) implementation in PyTorch
Requires Python: >=3.11
Keywords: pytorch, loop, outlier-detection, anomaly-detection, machine-learning, unsupervised-learning

# PyTorch LoOP

## Introduction

`pt_loop` is a pure PyTorch implementation of the Local Outlier Probabilities (LoOP) algorithm, designed for seamless integration into PyTorch-based machine learning pipelines.
It offers high performance on both CPU and GPU (CUDA), leveraging PyTorch's tensor capabilities throughout the entire computation.

Unlike traditional implementations that might require data transfers to other libraries, `pt_loop` keeps your data on the PyTorch device (CPU or GPU) from start to finish, minimizing overhead and maximizing efficiency for large-scale anomaly detection tasks.

The original paper can be found here: <https://www.dbs.ifi.lmu.de/Publikationen/Papers/LoOP1649.pdf>

## Installation

`pt_loop` requires PyTorch.

First, ensure you have PyTorch installed (refer to the [official PyTorch website](https://pytorch.org/get-started/locally/) for installation instructions specific to your system and CUDA version).

Then, install `pt_loop` directly from PyPI:

```bash
pip install pt_loop
```

## Quick Start & Usage Examples

Here's how to get started with `pt_loop`.

```python
import torch
import matplotlib.pyplot as plt

from pt_loop import loop
```

### Basic LoOP Usage

```python
# 1. Generate some synthetic data with an obvious outlier
data = torch.cat([
    torch.randn(100, 2) * 0.5 + torch.tensor([0.0, 0.0]), # Cluster 1
    torch.randn(100, 2) * 0.5 + torch.tensor([5.0, 5.0]), # Cluster 2
    torch.tensor([[2.5, 2.5]]),                           # Clear outlier
])

# Move data to GPU if available
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
data = data.to(device)

# 2. Run LoOP
print(f"Running LoOP on {device}...")
loop_scores = loop(
    data,
    k=10,                      # Number of nearest neighbors
    lambda_=3.0,               # Scaling factor
    distance_metric="l2",      # or "cosine"
)

print("\nLoOP Results:")
print(f"Scores Shape: {loop_scores.shape}")
print(f"First 5 Scores: {loop_scores[:5].tolist()}")
print(f"Last score (outlier candidate): {loop_scores[-1].item()}")

# 3. (Optional) Visualize the scores
plt.figure(figsize=(8, 6))
scatter = plt.scatter(data[:, 0].cpu(), data[:, 1].cpu(), c=loop_scores.cpu(), cmap="plasma", s=50, alpha=0.8)
plt.colorbar(scatter, label="LoOP Score (Outlier Probability)")
plt.title("Local Outlier Probabilities (LoOP)")
plt.xlabel("Feature 1")
plt.ylabel("Feature 2")
plt.grid(True)
plt.show()
```

## Contributing

Contributions are very welcome! If you find a bug, have a feature request, or want to contribute code, please feel free to:

1. Open an issue on the [GitLab Issues page](https://gitlab.com/hassonofer/pt_loop/-/issues).
1. Submit a Pull Request.

Please ensure your code adheres to the existing style (Black, isort) and passes all tests.

## License

This project is licensed under the Apache-2.0 License - see the [LICENSE](https://gitlab.com/hassonofer/pt_loop/blob/main/LICENSE) file for details.
koaviewer 1.0.2
Astronomical image display and interaction.
Requires Python: >=3.6

# KOAViewer Plotly/Dash Application

Dash contains a very large number of components for data display and UI configuration.  However, specialized display and interaction components are sometimes needed to fill discipline-specific roles.  All Dash components are written using React, a JavaScript library for building user interfaces, written and maintained by Facebook. 

"mviewer" (also available through PyPI) is a Dash React component, part of an interactive astronomical image viewer written as part of the Montage toolkit (http://montage.ipac.caltech.edu).  mviewer really only handles the display window and functions like zooming and panning.  It is the front-end for Python-based Dash apps which control what data gets displayed. The Dash app also handles the processing of "pick" and "draw box" events from mviewer.

"koaviewer" is one such Dash app.  It reads image and astronomical catalog data from local files and creates an interactive display with two floating data viewers: one for the image data (a single grayscale FITS file or three FITS files as a red/green/blue color composite); and another for atabbed set of the catalogs as data tables.  The image display is an mviewer instance and the table displays are Ag-Grid renderings wrapped by Dash.  

Selecting locations in the image display gets fed to the tables and records in the tables close enough to the location get marked.  Likewise, records selected from the tables get marked on the image.  This is basic dashboard functionality and other displays (like scatter plots, etc.) could be added but are not used in this example.

The Dash app does not itself render the image/overlay graphics that get display.  For that it relies on a Python-callable Montage library.
All of this is covered in more detail at http://montage.ipac.caltech.edu/docs/mViewer_DASH .

"koaviewer" is pure Python.
simple-media-sorter 1.0.150
A set of python modules to sort and clean media files
Requires Python: >=3.6

# Simple Media Sorter
<!-- ![SMS](https://raw.githubusercontent.com/hanzo-hasashi/SimpleMediaSorter/main/MediaSorter.png) -->
<img src="https://raw.githubusercontent.com/hanzo-hasashi/SimpleMediaSorter/main/MediaSorter.png" width="512">

- Set of Python scripts to sort and rename media files...
- This mainly utilizes the EXIF plugin to extract metadata and perform operations accordingly.
- Useful when working on media files from different sources like merging local and Google Photos Takeout files.
- Please take a backup of your files before performing any action using the script!

## Configuration
The scripts require source & destination folders. Configure them in the config_media_sorter.py file:

- source_directory_para = r"C:\Users\admin\Desktop\Unsorted" #path to source folder
- destination_directory_para = r"C:\Users\admin\Desktop\Out" #path to destination folder

## Scripts
- [Copy Files.py](https://github.com/hanzo-hasashi/SimpleMediaSorter/blob/main/Copy%20Files.py): Copies files with specific extensions while maintaining the folder structure.
- [EXIF Search Move.py](https://github.com/hanzo-hasashi/SimpleMediaSorter/blob/main/EXIF%20Search%20Move.py): This searches for EXIF Tag "keyword" and moves them to a sub-folder.
- [EXIF Tags Copier.py](https://github.com/hanzo-hasashi/SimpleMediaSorter/blob/main/EXIF%20Tags%20Copier.py): This copies specified EXIF tags from files in the Source Directory to the Destination Directory. Files must be present in both folders with the same name.
- [EXIF Tags Extracter.py](https://github.com/hanzo-hasashi/SimpleMediaSorter/blob/main/EXIF%20Tags%20Extracter.py): This extracts specific EXIF tags from images & videos and stores them into a CSV file.
- [moveToFolder_IMG_VID_EXIF.py](https://github.com/hanzo-hasashi/SimpleMediaSorter/blob/main/moveToFolder_IMG_VID_EXIF.py): Use this script to move image & video files to "YYYY\MMYY" folder (example 2019\0119 January). For images, the date is extracted from the EXIF tag; for videos, this date is extracted from the QuickTime tag.
- [update_EXIF_Date_fromFileName.py](https://github.com/hanzo-hasashi/SimpleMediaSorter/blob/main/update_EXIF_Date_fromFileName.py): Use this script to extract DateTime from file (YYYYMMDD) and update it in the EXIF.
- [update_EXIF_Dates_fromSystemDates.py](https://github.com/hanzo-hasashi/SimpleMediaSorter/blob/main/update_EXIF_Dates_fromSystemDates.py): Use this script to copy SystemDate into EXIF Date tags.
- [update_File_Name_fromEXIF.py](https://github.com/hanzo-hasashi/SimpleMediaSorter/blob/main/update_File_Name_fromEXIF.py): Use this script to update filename.jpg to filename_Date_Time.jpg