semvec/pypi-packages huggingface dataset:
IMPROVE-LIB 0.1.2
Within the IMPROVE project, we address some of the challenges around model comparisons, dataset standardization, and availability through the development and provision of a software framework. The goal is to make it routine practice for the broader community (cancer research and other areas) to compare new machine learning modeling approaches to previous models rigorously and comprehensively.
Requires Python: >=3.6

# IMPROVE
Libraries and scripts for the IMPROVE project.

## Purpose

## Installation
Clone the `IMPROVE library` repository to a directory of your preference (outside of your drug response prediction (DRP) model's directory).

```bash
git clone https://github.com/JDACS4C-IMPROVE/IMPROVE
cd IMPROVE
git checkout develop
```

## Download data
Download the [cross-study analysis (CSA) benchmark data](https://web.cels.anl.gov/projects/IMPROVE_FTP/candle/public/improve/benchmarks/single_drug_drp/benchmark-data-pilot1/) into your model's directory. For example:
```bash
./scripts/get-benchmarks $DESTINATION/csa_data/raw_data
```

The directory structure should look like this after the above steps have been completed:

```
IMPROVE
DRP_model
└── csa_data
```

## Set environment variables

Specify the full path to the `IMPROVE library` with $PYTHONPATH and the path to the CSA data with $IMPROVE_DATA_DIR.
```bash
cd DRP_model
export PYTHONPATH=$PYTHONPATH:/your/path/to/IMPROVE
export IMPROVE_DATA_DIR="./csa_data/"
```

## Tutorial
For a detailed guide on how to use the `IMPROVE library` using an example model, LightGBM, see https://jdacs4c-improve.github.io/docs/content/unified_interface.html.

## Examples
Two repositories demonstrating the use of the `IMPROVE library` for drug response prediction:
* https://github.com/JDACS4C-IMPROVE/GraphDRP/tree/develop -- GraphDRP (deep learning model based on graph neural network)
* https://github.com/JDACS4C-IMPROVE/LGBM/tree/develop -- LightGBM model
ConsoleVerse 0.1.0
A Python library for managing console output.
Requires Python: >=3.8

# 💻 ConsoleVerse


<center>
<img src="docs/img/ConsoleVerse_logo_fullcolor.png" width="150" style="border-radius: 25%;">

<hr>

[![License](https://img.shields.io/github/license/JuanS3/consoleverse)](https://github.com/JuanS3/consoleverse/blob/main/LICENSE)
[![License](https://img.shields.io/github/languages/code-size/JuanS3/consoleverse?color=green&logo=python)](https://img.shields.io/github/languages/code-size/JuanS3/consoleverse?color=green&logo=python)

</center>



ConsoleVerse is a **Python** library that provides a set of tools for managing console output, input and styling. It aims to simplify console interactions and improve user experience.

## 🚀 Features

- Simple and intuitive library interface
- Customizable styling options
- Support for progress bars
- Cross-platform compatibility

## 💾 Installation

To install ConsoleVerse, simply run:

```python
# from PyPI
pip install consoleverse # is not available yet

# from GitHub
pip install git+https://github.com/JuanS3/ConsoleVerse.git
```


## 📕 Getting Started

To use ConsoleVerse in your Python project, simply import it and start using its features:

```python
>>> from consoleverse import console

>>> console.println("Hello, ConsoleVerse!")
... Hello, ConsoleVerse!

>>> console.inputln("Your name? ")
... Your name?

>>> matrix = [
>>>     [1, 2, 3],
>>>     [4, 5, 6]
>>> ]
>>> print_matrix(matrix)
...
...     0  1  2
...     -------
... 0 | 1  2  3 |
... 1 | 4  5  6 |
...     -------

>>> print_matrix(
>>>     matrix,
>>>     header=['one', 'two', 'three'],
>>>     indexes=['row1', 'row2'],
>>>     style='semibox'
>>> )
...
...          one     two    three
...        -----------------------
... row1 |    1       2       3
... row2 |    4       5       6
```

For more detailed usage instructions, please see the usage documentation.

## 📃 Examples
Check out the [examples directory](examples/) for some sample code demonstrating ConsoleVerse's capabilities.

## 🖐🏻 Contributing
Contributions to ConsoleVerse are welcome and appreciated! Please see the [contribution guidelines](CONTRIBUTING.md) for more information on how to get involved.

## 📜 License
ConsoleVerse is released under the [MIT License](LICENSE). See the [license file](LICENSE) for more information.

## 👏🏻 Credits
ConsoleVerse was developed by [JuanS3](github.com/JuanS3).
subproptools 0.4.3
A plugin for extracting data from .sum files and manipuating them
Requires Python: >=3.10
Keywords: qtaim, functional groups


[![ci](https://github.com/kmlefran/subproptools/actions/workflows/ci.yml/badge.svg)](https://github.com/kmlefran/subproptools/actions/workflows/ci.yml)
[![Documentation Status](https://readthedocs.org/projects/subproptools/badge/?version=latest)](https://subproptools.readthedocs.io/en/latest/?badge=latest)
[![Coverage Status](https://coveralls.io/repos/github/kmlefran/subproptools/badge.svg?branch=main)](https://coveralls.io/github/kmlefran/subproptools?branch=main)
[![PyPI version](https://badge.fury.io/py/subproptools.svg)](https://badge.fury.io/py/subproptools)
# Molecule Reorientation and .sum file handling

This package provides tools to extract data from .sum files (in the qtaimExtract module), and tools to reorient the molecule to defined coordinate systems (in the subreor module). The subreor module rotates to a defined coordinate system. First an atom is positioned at the origin. By convention, this is the atom of the group that is directly bonded to the rest of the molecule. The rest of the molecule is placed along the -x axis. The remaining axes are defined as follows:
* if there is one lone pair(VSCC), that point lies on the +y
* if there are two lone pairs, the average position of them lies on the +y
* if there are no lone pairs, map the BCPs of the atom at the origin to a reference. Identify the closest match to the reference to determine a BCP to set as +y

# Authors
Kevin Lefrancois-Gagnon
Robert C. Mawhinney

# Installation prior to distribution
```
pip install git+https://github.com/kmlefran/subproptools
```

# User Facing Functions:
## subreor
* rotate_sheet - performs rotations to the desired coordinate system for many molecules as defined in a csv file
* output_to_gjf - writes the reoreinted geometry to a .gjf file
* rotate_substituent - performs the defined rotation for an individual substituent

## qtaimExtract
* get_sub_di - gets delocalization index between a substituent and the rest of the molecule
* get bcp_properties - returns a dictionary of bcp properties for a given bcp
* get_atomic_props - returns dictionary of atomic properties for all atoms in molecule
* get_cc_props - returns dictionary of properties for all charge concentrations
* identify_vscc - returns only the VSCC from a set of charge concentrations
* get_sub_props - returns dictionary of one substituent's properties
* extract_sub_props - returns dictionary of atomic, group, bcp and vscc properties for a substituent
* sub_prop_frame - returns dictioanry of frames of group properties
* get_xyz - extracts a molecule's xyz geometry from sum file
montpy 0.1.2
Library implementing Monte Carlo and Quasi-Monte Carlo methods for integral evaluation
Requires Python: >3.8

# Montpy: Montecarlo and Quasi-Montecarlo Integration Library
<div style="text-align:center">
    <a href="https://pypi.org/project/montpy/">
        <img src="https://img.shields.io/pypi/dm/montpy.svg" alt="Monthly Downloads">
    </a>
</div>


This Python library provides implementations of Monte Carlo and Quasi-Monte Carlo methods for evaluating integrals. Monte Carlo methods are stochastic techniques based on random sampling, while Quasi-Monte Carlo methods use low-discrepancy sequences for sampling. These methods are particularly useful for high-dimensional integrals where other numerical methods may struggle.

## Installation
You can install the library via pip:
```{bash}
pip install montpy
```

## Usage
```{Python}
from montpy.mc import MonteCarloSolver, ImportanceSampler
from montpy.qmc import QuasiMonteCarloSolver

# Define the function to integrate
def f(samples):
    x, y = samples.T
    return x**2 + y**2
    
# Define the domain (multivariate case)
domain = [(0, 1), (0, 1)]

# Create the Monte Carlo solver (uniform distribution)
solver_mc = ImportanceSampler(f, domain)
integral_mc = solver_mc.integrate(num_samples=1000)
print("Estimated integral with Monte Carlo:", integral_mc)

# Define the function to integrate
def g(x, y):
    return x*y
    
# Create the Quasi-Monte Carlo solver
solver_qmc = QuasiMonteCarloSolver(g, domain)

# Perform integration using Sobol sequence
integral_sobol = solver_qmc.integrate_sobol(num_samples=1000)
print("Estimated integral with Sobol sequence:", integral_sobol)
```

## Contributing
Contributions are welcome! If you find any bugs or have suggestions for improvements, please open an issue or submit a pull request on GitHub.

## License
This library is licensed under the MIT License. See the [LICENSE](https://github.com/ScipioneParmigiano/montpy/blob/main/LICENSE) file for details.
AuthSys 0.0.3
AuthSys is a Python library Allows you to create a membership system, so you add keys to your tools.
Keywords: AuthSys, Membership, Python library


# AuthSys

![GitHub stars](https://img.shields.io/github/stars/IceBytes/AuthSys?style=social)
![GitHub followers](https://img.shields.io/github/followers/IceBytes?style=social)

## Introduction
AuthSys is a Python library for Memberships system.

## Installation
You can install AuthSys using pip:
```bash
pip install AuthSys
```

## Usage

### Initialization
```python
from AuthSys import AuthSys

auth = AuthSys()
```

### Login
```python
# Logging in with a key and access token
response = auth.login(key="your_key", access_token="your_access_token")
print(response)
```

### Registration
```python
# Registering a new user
response = auth.register(time="registration_time")
print(response)
```

### Removing a user
```python
# Removing a user using their key and authentication secret
response = auth.remove(key="user_key", secret_auth="user_secret_auth")
print(response)
```

### Editing user information
```python
# Editing user information
response = auth.edit(key="user_key", auth="user_auth", time="new_time")
print(response)
```

## Contributing
Pull requests are welcome. For major changes, please open an issue first to discuss what you would like to change.

Please make sure to update tests as appropriate.

## License
[MIT](https://choosealicense.com/licenses/mit/)
templang 0.1.1
A simple annotation-based language to generate code from templates
Requires Python: >=3.10

# templang

> A simple annotation-based language to generate code from templates

## Templates

Templates are just source files with annotations. For example:

```python
# BEGIN
from typing import Literal

Rank = Literal[
  # LOOP RANK
  'RANK',
  # END
]

CLEARANCE_LEVEL = int # DELETE (just to make mypy happy)
# LOOP RANK CLEARANCE_LEVEL
class RANK:
  clearance_level: CLEARANCE_LEVEL

# END
# END
```

## Template Parsing

```python
from templang import parse
with open('ranks.py') as f:
  source = f.read()

code = parse(source, translations={
  'RANK': ['Captain', 'Lieutenant', 'Sergeant'],
  'CLEARANCE_LEVEL': ['1', '2', '3']
})

print(code)

# from typing import Literal
# 
# Rank = Literal[
#   'Captain',
#   'Lieutenant',
#   'Sergeant',
# ]
# 
# class Captain:
#   clearance_level: 1
# 
# class Lieutenant:
#   clearance_level: 2
# 
# class Sergeant:
#   clearance_level: 3
```

## Rules

Now, that's most of what you need to now. But, to be precise, here are the rules:

- `# BEGIN` and `# END` delimit a template
- Lines starting with `# UNCOMMENT` are stripped to whatever proceeds the annotation
- Lines ending with `# DELETE` are removed
- `translations: Mapping[str, str | Sequence[str]]` is the dictionary of translations:
  - If `value = translations[key]` is a string, all instances of `key` are replaced by `value`
  - If `value = translations[key]` is a sequence of strings, `key` will be allowed in a `# LOOP` declaration
  - The order of translations is not guaranteed. So, keys substrings of other keys will probably yield inentended results
- `# LOOP VAR1 ... VARN` and `# END` delimit a loop:
  - `translations[VARi]` must be a sequence of strings
  - `LEN = len(translations[VAR1]) == ... == len(translations[VARN])`
  - The template inside the loop is substituted with `translations[VARi][j]` for each `j in range(LEN)`	
  - Nested loops are allowed
  - If nested loops involve a same variable `VAR` multiple times, then `translations[VAR]` must be a nested sequence of strings (matching the loop depth)
    - E.g:
    
      ```python
      # BEGIN
      from typing import Union, Literal

      Marriage = Union[
      # LOOP NAMES
        tuple [
        # LOOP NAMES
          Literal['NAMES'],
        # END
        ],
      # END
      ]
      # END


      parse(open(__file__).read(), {
        'NAMES': [['John', 'Jane'], ['Stuart', 'Alice']]
      })

      # from typing import Union, Literal
      #
      # Marriage = Union[
      #   tuple [
      #     Literal['John'],
      #     Literal['Jane'],
      #   ],
      #   tuple [
      #     Literal['Stuart'],
      #     Literal['Alice'],
      #   ],
      # ]
      ```

- Oh, and actually, `#` can be replaced by any custom string (e.g. `//`)
expandex 0.0.1
Find images similar to a given source image
Requires Python: >=3.10


---

# Expandex

Expandex is a Python library designed to find images similar to a given source image. It utilizes online image searches, feature extraction, and image deduplication to retrieve unique and usable images.

## Installation

You can install Expandex via pip:

```bash
pip install expandex
```

## Usage

```python
from expandex import Locator

# Initialize Locator object
locator = Locator()

# Scout for similar images
similar_images = locator.scout('path_to_source_image.jpg')

# Display similar images
for image_url in similar_images:
    print(image_url)
```

## Features

- **Feature Extraction:** Employs feature extraction techniques to analyze and compare image features.
- **Image Deduplication:** Prevents the retrieval of duplicate images to ensure diversity in search results.
- **Multi-threaded Processing:** Utilizes multi-threading to enhance performance and speed up the image retrieval process.

## Configuration

You can configure Expandex by specifying parameters such as save folder location, deduplication method, and weights for similarity metrics.

```python
# Example Configuration
locator = Locator(
    save_folder='images',
    deduplicate='cpu',
    weights={
        'ih': 0.1,  # Image Hash similarity
        'ssim': 0.15,  # Structural similarity index measurement
        'cs': 0.1,  # NumPy cosine similarity
        'cnn': 0.15,  # EfficientNet feature extraction
        'dedup': 0.1  # Mobilenet cosine similarities
    },
    debug=True
)
```

## License

Expandex is licensed under the Apache License 2.0. See [LICENSE](LICENSE) for more details.

---