semvec/pypi-packages huggingface dataset:
extract-yt-url 0.0.1
A training package
Requires Python: >=3.6

# extract_yt_url
training module

## 추가 설명
사용자로부터 문자열을 입력받으면 해당 문자열과 관련된   
유튜브 링크를 찾아 문자열 또는 리스트로 반환하는   
기능을 구현한 라이브러리 모듈

## 사용 전 주의사항
```
pip install extract_yt_url
```
파이썬 버전은 3.6 이상 지원

## 기본 사용법
```
import Extract_yt_url from extract_yt_url
text1 = Extract_yt_url("Break Out").to_string()
list1 = Extract_yt_url("Break Out").to_list()
print(text1)
print(list1)
```

## 참고 자료
https://packaging.python.org/en/latest/tutorials/packaging-projects/#uploading-your-project-to-pypi   
https://github.com/joetats/youtube_search   
(MIT License - Copyright (c) 2019 joe tats)   
https://wikidocs.net/197255
explerr 0.1.0
Error explainer using LLMs
Requires Python: >=3.8

# ExplErr

A Python package that provides LLM-powered exception explanations.

Implemented using [APPL](https://github.com/appl-team/appl).

## Installation

```bash
pip install explerr
```

## Usage

### As a CLI tool

Instead of running your Python script with `python`, use `expython`:

```bash
expython your_script.py
```

### As a Python package

```python
from explerr import ExceptionWithExplanation

try:
    # Your code here
    result = 1 / 0
except Exception as e:
    raise ExceptionWithExplanation(e)
```
aoc-input-fetcher 0.1.2
A useful tool for getting the input automatically for Advent of Code, given you follow the file structure
Requires Python: >=3.6
Keywords: Advent of Code, input fetcher, automation

# Advent of Code Input Fetcher

`aoc_input_fetcher` is a Python package that automates fetching input files for [Advent of Code](https://adventofcode.com) challenges, assuming a specific file structure for your project.

---

## Features

- Automatically fetches input for Advent of Code puzzles from file name and directory sturcture.
- Supports user-provided session cookies for authentication.
- Simplifies managing input files for each day of the challenge.
- Easy to integrate with your existing workflow.

---

## Installation

You can install the package via pip:

```bash
pip install aoc_input_fetcher
```

## Usage

### Setup

To use aoc_input_fetcher, you need to:
	1.	Log in to Advent of Code and copy your session cookie.
	2.	Save the cookie to a .env file in the following format:
```bash
AOC_COOKIE=<your_session_cookie>
```


### File Structure

The package expects the following file structure for your Advent of Code project:


```
aoc/2024/
├── day1.py
├── day5.py
├── inputs/
│   ├── day1.txt
│   └── day5.txt
```
### Fetch Input

Example of fetching input for Day 1:
```python
from aoc_input_fetcher import fetch_input

input = fetch_input(__input__)
```
This will download the input for Day 1 and save it to inputs/day1.txt in the project root. The input is returned as a string as well.

**Demo**

Here’s a quick demo of how to use the package:

from aoc_input_fetcher import fetch_input
```python
from aoc_input_fetcher import fetch_input

def main():
    input = fetch_input(__file__)
    if input is None:
        return
    formatted_input = format_input(input)
    print(part1(formatted_input))
    print(part2(formatted_input))
main()
```
For a detailed look at how I have been using it check out my [Advent of Code repository](https://github.com/mourud/advent-of-code/tree/main/2024)

## Requirements
This package requires:
	•	Python 3.6 or newer
	•	requests library (automatically installed with the package)
    •   python-dotenv library (automatically installed with the package)

## Contributing
Contributions are welcome! If you have ideas for improvements or find bugs:
	1.	Fork the repository.
	2.	Make your changes.
	3.	Submit a pull request.

## License
This project is licensed under the MIT License. See the LICENSE file for details.

## Support
If you encounter issues or have questions, feel free to open an issue on GitHub.
autoafids 0.1.4
End-to-end SnakeBIDS workflow for landmark regression and derivative apps
Requires Python: <3.12,>=3.8

# Automatic Anatomical Fiducials (autoAFIDs)
AIMS Lab Research Team at the Robarts Research Institute - 2023-2024

*This package is under active development. It should be stable and reproducible, but please let any of the active contributing members know if there are any bugs or unusual behaviour.*

This Python package is a standard 3D [U-Net](https://arxiv.org/abs/1505.04597) (Ronneberger et al. 2015) machine learning model based on Snakemake and SnakeBIDS workflow management tools that leverages the recent release of the anatomical fiducial framework to solve the landmark regression problem on 3D MRI images. It is currently in development phase and contains tunable parameters that are not normally exposed in most other machine learning models; the user is highly advised to get familiar with the above mentioned workflow managaments tools and read docstrings and relevant documentation before using this software. Please see the [changelog](CHANGELOG.md) for more details. 

## Table of Contents
1. [Installation](#installation)
2. [Workflow](#workflow)
2. [Train](#train)
3. [Apply](#apply)
4. [Known issues](#known-issues)
5. [Roadmap](#roadmap)
6. [Questions, Issues, Suggestions, and Other Feedback](#questions--issues)

## Installation 

### Installing Poetry
We use poetry tool for dependency management and to package the python project. You can find step by step instructions on how to install it by visiting it's official [website](https://python-poetry.org/docs/).

### Local Installation

After installing poetry, clone this repository via:

```bash
git clone https://github.com/afids/autoafids.git
```

You can then install the python package using one of the following commands, which should be executed within the repository folder (i.e., autoafids/).

```bash
poetry install
```
If you want to install in _develop mode_, use:

```bash
poetry install -e
```

## Workflow
Brief summary of the workflow along with its Directed Acyclic Graph (DAG) can be found below. 

*Insert DAG image - inspired by khanlab/scattr*

### Processing landmark data (AFIDs)
1. Extract fiducial points from the landmark files (.fcsv is supported)
2. Generate a landmark Euclidean distance/probability map with each voxel communicating distance to an AFID of interest

## Train
Currently, we support generating your own models (i.e., training) in a sperate workflow (i.e., afids-cnn: <LINK>). For more details, see [Known Issues](#known-issues).


## Apply
<TODO>
  
## Known Issues
- Factorize apply workflow to run per landmark of interest

## Roadmap

- Model optimization
- Extension to incorporate new modalities (i.e., CT scans)

## Questions, Issues, Suggestions, and Other Feedback
Please reach out if you have any questions, suggestions, or other feedback related to this software—either through email (dbansal7@uwo.ca) or the discussions page. Larger issues or feature requests can be posted and tracked via the issues page. Finally, you can also reach out to Alaa Taha, the Science Lead.
mfishtoolspy 0.0.1
Tools for mFISH data analysis and gene panel selection
Requires Python: >=3.7

# mfishtoolspy
- Tools to analysis mFISH data, including gene panel selection from reference dataset.
- This is a python version of https://github.com/AllenInstitute/mfishtools with slight modifications
  - Bootstrapping instead of subsampling
  - Multiple iterations (default=100) per gene addition instead of single random seed to increase reliability across repetition
  - Parallel computing using dask
  - Some functions are not included yet. (e.g., fraction_correct and dendrogram_height optimization)
- This is still in active development (as of 12/10/2024)

## How to install
`git clone https://github.com/AllenNeuralDynamics/mfishtoolspy.git`
`cd mfishtoolspy`
`pip install -e .`
pyimg3lib 1.2.5
iOS Image3 lib
Requires Python: <4.0,>=3.11


This code will interact with Apple's img3 data.

# Credits

axi0mX: ipwndfu \
plzdonthaxme (plx): Help with figuring out the iOS 3.0 kernel decompression stuff and pointing out what I've been doing wrong \
m1stadev: lzss fixes
pyggdrasil 0.1.1
A tiny library to print trees
Requires Python: <4.0,>=3.12

 This is a tiny library to print nested dictionaries as trees in the format of
 file trees.

 # Install

    pip install pyggdrasil


# Use

```
>>> from pyggdrasil import render_tree
>>>
>>> data = {
>>>     1: {
>>>         "a": ["A", "B", "C"],
>>>         "b": ["D", "E"]
>>>     },
>>>     2: {
>>>         "x": ["V", "W", "Q"],
>>>         "y": ["Y", "Z"],
>>>         "z": ["X", "Y"],
>>>     }
>>> }
>>> print(render_tree(data))

├─ 1
│  ├─ a
│  │  ├─ A
│  │  ├─ B
│  │  └─ C
│  └─ b
│     ├─ D
│     └─ E
└─ 2
   ├─ x
   │  ├─ V
   │  ├─ W
   │  └─ Q
   ├─ y
   │  ├─ Y
   │  └─ Z
   └─ z
      ├─ X
      └─ Y
```
compas-surrogate.acquisition-plotting 0.1.3
Plotting utils
Requires Python: >=3.8

# Acquisition Plotting

[![PyPI version](https://badge.fury.io/py/compas-surrogate.acquisition-plotting.svg?icon=si%3Apython)](https://badge.fury.io/py/compas-surrogate.acquisition-plotting)


Some plotting utils and KL divergence calculation for final posteriors.
compas-surrogate.ogc4-interface 0.0.1
Interface to OGC-4 (https://github.com/gwastro/4-ogc)
Requires Python: >=3.8

# OGC-4 Interface

[![PyPI version](https://badge.fury.io/py/compas-surrogate.ogc4-interface.svg?icon=si%3Apython)](https://badge.fury.io/py/compas-surrogate.ogc4-interface)

This repo interfaces with [OGC-4](https://github.com/gwastro/4-ogc) to read in posterior samples for the LVK GW events.

The `PopulationMcZ` class is the main API interface, and is used to get the Mc-z posterior samples and
priors for all the events, and cache them as a matrix of binned Mc-z weights.


```python
from ogc4_interface.population_mcz import PopulationMcZ

population = PopulationMcZ.load()
population.plot_event_mcz_estimates()
population.filter_events(threshold=0.95)
population.plot_weights()
```

## Events
![](docs/_static/event_mcz_estimates.jpeg)


## Weights
![](docs/_static/weights.jpeg)
omero-rdf-wikidata 0.1.0
Wikidata extension for omero-rdf
Requires Python: >3.8
Keywords: OMERO.cli, plugin

.. image:: https://github.com/German-BioImaging/omero-rdf-wikidata/workflows/OMERO/badge.svg
    :target: https://github.com/german-bioimaging/omero-rdf-wikidata/actions

.. image:: https://badge.fury.io/py/omero-rdf-wikidata.svg
    :target: https://badge.fury.io/py/omero-rdf-wikidata

omero-rdf-wikidata
==================

Wikidata extension for omero-rdf


Requirements
============

* OMERO 5.6.0 or newer
* Python 3.9 or newer


Installing from PyPI
====================

This section assumes that an OMERO.py is already installed.

Install the command-line tool using `pip <https://pip.pypa.io/en/stable/>`_:

::

    $ pip install -U omero-rdf-wikidata

Release process
---------------

This repository uses `versioneer <https://pypi.org/project/versioneer/>`_
to manage version numbers. A tag prefixed with `v` will be detected by
the library and used as the current version at runtime.

Remember to ``git push`` all commits and tags.

Funding
-------

Funded by the `Delta Tissue <https://wellcomeleap.org/delta-tissue/>`_
Program of `Wellcome Leap <https://wellcomeleap.org/>`_.

License
-------

This project, similar to many Open Microscopy Environment (OME) projects, is
licensed under the terms of the GNU General Public License (GPL) v2 or later.

Copyright
---------

2024, German BioImaging
nova-scheduler-filters 0.1.0
Additional filters for the OpenStack Nova scheduler
Requires Python: >=3.8

======================
Nova Scheduler Filters
======================

This project contains a set of filters for the Nova scheduler.  These filters
are intended to be used in conjunction with the default filters that ship with
Nova.

The goal of those filters are to provide additional filtering capabilities
that can be co-installed with any version of Nova until the features are
upstreamed.

--------------
Failure domain
--------------

The failure domain filter is a filter that can be used to spread instances
across different failure domains.  A failure domain is a set of compute nodes
that are expected to fail together.  For example, compute nodes in the same
rack or in the same power distribution unit (PDU) are expected to fail
together.

Historically, some users have used the availability zone feature to spread
instances across failure domains.  However, the availability zone feature is
not designed for this purpose and it has some limitations.  There is also
a need to spread instances across failure domains within the same availability
zone.

The failure domain is defined as a metadata on host aggregates.  The key of
the metadata is ``failure_domain``.  The value of the metadata is a string that
identifies the failure domain.  The failure domain filter will spread instances
across different failure domains.  It is up to the operator to define the
failure domains.
torch-sparse-autoencoder 0.1.0
A sparse autoencoder implementation in Python for the PyTorch library
Requires Python: >=3.11

# Torch Sparse Autoencoder

A Python library for implementing sparse autoencoders using PyTorch.

## Installation

```bash
pip install torch-sparse-autoencoder
```

## Usage

```python
from torch_sparse_autoencoder import SparseAutoencoderManager

# Create a sparse autoencoder
manager = SparseAutoencoderManager(
    model=model,
    layer=target_layer,
    activation_dim=activation_dim,
    sparse_dim=activation_dim*4,
    device=device
)

# Train the autoencoder
manager.train(
    torch_dataset,
    num_epochs=5,
    batch_size=4,
    sparsity_weight=1e-3,
    verbose=True
)

```

## License

This project is licensed under the MIT License - see the LICENSE file for details.
typing-test-sapien 3.0.2
A CLI-based typing speed test application
Requires Python: >=3.1

# Typing Speed Test with a Knowledge Twist

This project combines a fun typing speed test with an engaging knowledge dataset to measure typing speed (Words Per Minute) and accuracy while learning something new.

## Features
- **Typing Speed Measurement**: Calculates Words Per Minute (WPM) for each test.
- **Accuracy Calculation**: Computes the percentage of correctly typed words.
- **Knowledge Dataset**: Sentences are sourced from a specially curated dataset, including:
  - **Fun Facts**: Trivia that will amaze you.
  - **Health Tips**: Simple tips for a better lifestyle.
  - **Science & Math Wonders**: Discover fascinating facts.
  - **Famous Quotes**: Iconic sayings from great minds.
  - **Movie Dialogues**: Relive legendary cinematic moments.
- **Blind Mode**: Optional feature to hide user input for an added challenge.
- **Bar Chart Visualization**: Summarizes session performance with a bar chart.

## How It Works
1. **Sentence Selection**: Random sentences are selected from the knowledge dataset. [*You’ll absolutely love this!*]
2. **Timing**: Tracks the time taken for the user to type the sentences.
3. **WPM and Accuracy**: Calculates WPM and accuracy based on input.
4. **Session Summary**:
   - Average typing speed.
   - Average accuracy.
   - Final result (PASS or FAIL).

## Installation
Install the required package using pip:
```bash
pip install typing-test-sapien
```
## Execution
```bash
typing-test-sapien

or

typing-test-sapien 5 2 yes
```
   - `5`: Number of tests.
   - `2`: Sentences per test.
   - `yes`: Enables blind mode.

## Example Output
```
Final Results
-------------
Average Accuracy:         85.50%
Average Typing Speed:     72.00 WPM
Result:                   PASS

Session Progress Bar Chart
-------------------------------------------------
WPM       | T1    T2    T3    T4    T5    
-------------------------------------------------
80        |  #     #     #                   
75        |  #     #     #                   
50        |        #     #                   
-------------------------------------------------
```

## Requirements
- Python 3.x
- `getpass` module (comes pre-installed with Python).

## License
This project is licensed under the MIT License.
safevitals 1.0.3
APK Vulnerability Scanner by Safe Vitals
Requires Python: >=3.6

# Safe Vitals

**Safe Vitals** is a Python-based APK vulnerability scanner that decompiles APKs, runs security scans, and generates detailed PDF reports.

## Features
- Decompiles APKs
- Runs MobSF scans
- Generates a PDF vulnerability report

## Requirements

This project requires the following external tools to be installed and available in the system's `PATH`:

1. **apktool**
   - Used for reverse-engineering APK files.
   - Installation:
     ```bash
     sudo apt install apktool  # On Linux
     brew install apktool      # On macOS
     ```
     For other platforms, follow the instructions [here](https://ibotpeaches.github.io/Apktool/).

2. **dex2jar**
   - Converts DEX files into JAR format for decompilation.
   - Installation:
     - Download the latest release from [GitHub](https://github.com/pxb1988/dex2jar).
     - Extract the files and add the directory to your `PATH`.
     ```bash
     export PATH=$PATH:/path/to/dex2jar
     ```
## Install
     pip install safebitals

## How To Run
     safebitals -a file.apk
    
## License

This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.