semvec/pypi-packages huggingface dataset:
digitalarztools 0.2.5
DigitalArz Tools for applications
Requires Python: >=3
Keywords: raster, vector, digitalarz

# DigitalArz Tools
Tools for providing GIS capabilities in the DigitalArz Application. Tools are based on

1. RasterIO
2. GeoPandas
3. Shapely
4. Scikit-learn

Modules are

## Raster

1. rio_raster: to extract raster information and read and write operation using raster io
2. rio_process: to perform different process on a raster
3. rio_extraction : to extract data from different pipelines like GEE
4. indices

## Vector

1. gpd_vector: to extract vector and perform operation using geopandas

## Pipeline

To add the account in the digitalarztool module, you have to open the python console. 
Activate the venv environment and  open python in this environment. In console use following commands
```angular2html
from digitalarztools.pipelines.config.server_settings import ServerSetting
ServerSetting().set_up_account("NASA")
```
Following piplines are available

1. gee: pipeline with google earth engine for processing and extracting data
2. srtm: pipeline to extract SRTM data from
3. nasa: pipeline to extract NASA data. First need to setup account using
    ```
   SeverSetting.set_up_account("NASA")
   ```
   alos palsar: to extract alos palsar RTC data using earthsat api

4. grace & gldas: to extract grace and gldas data using ggtools(https://pypi.org/project/ggtools/). Grace data is
   available at https://podaac.jpl.nasa.gov/dataset/TELLUS_GRAC-GRFO_MASCON_CRI_GRID_RL06_V2
5. ClimateServ Date: https://pypi.org/project/climateserv/ 
6. CHIRP: download Rainfall data.
PytatoDIA 0.6.0
A Toolbox for Proteomic Analyses and Data Visualization
Requires Python: >=3.6

# Pytato: A Toolbox for for DIA Proteomics

Pytato is a dual-enzyme proteomics search engine that leverages the information provided by complementary proteolysis to improve peptide and protein identification in data-independent proteomics experiments. 

![logo_small](https://user-images.githubusercontent.com/36017084/229610464-03d73a08-c55e-4e9f-8dec-ac0af352a945.png)


## Experimental Example

Enyzme1=Trypsin
Enzyme2=Thermolysin

## Features

- Custom Python-based pipeline for streamlined analysis
- Support for multiple proteases to improve protein identification confidence
- Generation of theoretical spectra for improved peptide matching



## Installation

```bash
git clone https://github.com/TTCooper-PhD/Pytato.git
```

Install the required python packages:

```bash
pip install -r requirements.txt
```

## Usage
- Prepare your Enzyme1 and Enzyme2-digested samples and acquire LC-MS/MS data in DIA mode.
### For a list of available enzymes and their cleavage rules, see the [Available Enzymes](enzymes.md) document.

- Process raw data files and generate spectral libraries for both Enzyme1 and Enzyme2 samples.
- Run Pytato by providing the necessary input files and parameters.

```bash
python pytato.py --enzyme1_data trypsin_data.mzML --enzyme2_data thermolysin_data.mzML  --output output_directory
```
## Output
Pytato generates multiple output files containing the results of the analysis. (Add specific details about the output files here).

## Examples
(Provide a detailed example command with input and expected output)

## Contribution
We welcome contributions to the Pytato project. Please see our contribution guidelines for more details.

## License
(Provide details about the project's license)

## Contact
For questions or feedback, please contact us at (Your contact info).
auth-db-neonix 0.2.2
User auth, settings management, and local DB handling with Firebase and SQLite
Requires Python: >=3.9

# auth-db-neonix

Authentication and settings management module for Python apps using Firebase for auth and SQLite for local data.

## 🚀 Features

* 🔐 Firebase-based user authentication
* 🔁 Cookie and session management
* 💾 Firebase Firestore settings persistence
* 🗄️ SQLite-based local data layer
* 🧰 Pluggable architecture (DTOs, Services, Models)

## 📦 Installation

### From GitHub

```bash
pip install git+https://github.com/NeoNix-Lab/neoquant-auth-manager.git
```

### For Development

```bash
pip install "git+https://github.com/<your-username>/auth_db_neonix.git#egg=auth_db_neonix[dev]"
```

## 🔧 Usage

```python
from auth_db_neonix import login_user, register_user, DataRetriever

user = register_user("you@example.com", "yourpassword")
cookie = login_user("you@example.com", "yourpassword")

data = DataRetriever.from_settings(user.uid, db_setting)
```

## 🧪 Run Tests

```bash
pytest tests/
```

## 📁 Project Structure

```
.
├── auth_db_neonix/
├── tests/
├── pyproject.toml
├── README.md
├── .gitignore
└── LICENSE
```

## 📄 License

MIT License (see `LICENSE` file)
pycaber 0.1.3
Caber DREAM: Deterministic Attribution and Control of AI Data Use
Requires Python: >=3.9

# PyCaber

Caber DREAM Python Package

Caber DREAM dynamically enriches every chunk in your Retrieval‑Augmented Generation (RAG) datastore with trusted source attributed metadata so you always know what the data is, where it came from, who owns it, and how it may be used.

## Installation

```bash
pip install pycaber
```

## Usage

```python
import pycaber

# Your code here
```

## Development

To build the extension locally:

```bash
maturin develop --release
```

To generate Python stub files (for IDE support):

```bash
python3 generate_stubs.py
```

## Features

- High-performance Rust-based implementation
- Type hints and IDE support through included stub files
- Cross-platform compatibility (Linux x86_64 and aarch64)
- Python 3.9+ support
tidybit2 0.1.7
A CLI tool to organize files into system and custom folders
Requires Python: >=3.6


# 📁 TidyBit 2

**TidyBit 2** is a sleek, interactive command-line tool that brings order to chaos—automatically sorting your messy directories into proper **system folders** like `Pictures`, `Documents`, and `Videos`, or custom folders like `Archives`.

✨ Designed with an intuitive CLI experience, complete with interactive folder selection, preview mode, and final confirmation.

---

## 🚀 Features

- 🧭 **Interactive folder selection** with arrow keys (powered by [`questionary`](https://github.com/tmbo/questionary))
- 🔍 **Preview moves** before committing (`example.jpg → Pictures`)
- ✅ **Confirmation prompt** to avoid accidents
- 🗂️ Intelligent file mapping:
  - `.jpg`, `.png`, `.jpeg` → `Pictures`
  - `.pdf`, `.docx`, `.txt` → `Documents`
  - `.mp4`, `.mov`, `.avi` → `Videos`
- 📦 Unmatched formats like `.zip`, `.rar`, `.7z` go to `Archives`
- 🧠 Auto-creates destination folders if missing
- 💻 Works on **Windows**, **Linux**, and **macOS**

---

## 🛠️ Installation

Install directly from PyPI:

```bash
pip install tidybit2
````

> If `pip` isn’t recognized, try:
>
> ```bash
> python -m pip install tidybit2
> ```
>
> Or on Linux/macOS:
>
> ```bash
> pip3 install tidybit2
> ```

All dependencies (like `questionary`) are installed automatically.

---

## 🧪 Example Usage

```bash
organize
```

You’ll be prompted to:

1. Select a directory to organize
2. Preview how files will be moved
3. Confirm the action

---

## 📂 How It Works

TidyBit 2 classifies files by extension and moves them to appropriate folders, keeping your system neat and uncluttered. Everything is interactive, reversible, and user-friendly.

---

## 🧰 Tech Stack

* Python 3.7+
* [`questionary`](https://github.com/tmbo/questionary)
* Cross-platform file system operations

---

## 🤝 Contributing

Got ideas? Issues? Wanna add support for more file types or OS features?

1. Fork this repo
2. Create a feature branch
3. Submit a pull request


The repo is: https://github.com/A96-45/tidybit2.git

PRs are welcome like a `.jpg` in your `Downloads` folder since 2019.

---

## 📄 License

MIT License © 2025 — \[YourName or Org]

---
bitmark 1.0.1
bitmark is a simple yet powerful utility to manage and parse bitflags represented as hexadecimal values, with support for user-defined flag sets stored in YAML files.
Requires Python: >=3.6

# bitmark

`bitmark` is a simple yet powerful utility to manage and parse bitflags represented as hexadecimal values, with support for user-defined flag sets stored in YAML files.

---

## Features

- Parse hexadecimal flags and display corresponding bit positions and names.
- Create custom YAML flag definition files.
- List available flag types.
- Open the directory where flag definitions are stored.
- Supports cross-platform usage (Windows, macOS, Linux).

---

## Installation

Install `bitmark` via pip:

```bash
pip install bitmark
```

## Usage

You can run bitmark directly from the command line.

## Commands
### parse

Parse a hexadecimal number to display its set bits and optionally use a flag type to show flag names.

```bash
bitmark parse <hex_number> [type_name]
```

- hex_number: The hexadecimal number to parse (e.g., 0x1F).
- type_name (optional): Name of the flag type YAML file (without .yml) to interpret flag names. (possibly a name of flags structure)


If no command is provided, bitmark assumes parse as default.

Example:
```bash
bitmark 0x1F myflags
```

or explicitly:
```bash
bitmark parse 0x1F myflags
```

---

### create

Create a new YAML flag definition file under ~/.bitmark (or .bitmark in current directory if home not found).

```bash
bitmark create <type_name> NAME1=VALUE1 NAME2=VALUE2 ...
```

- type_name: Name of the new flag type.
- Flags must be provided as NAME=VALUE pairs.
- Values can be decimal or hex (e.g., 0x01).

Example:

```bash
bitmark create myflags READ=0x01 WRITE=0x02 EXECUTE=0x04
```

---

### types

List all available flag types (names of .yml files in bitflags directory).

```bash
bitmark types
```

---

### db

Open the bitflags directory in your file explorer.

```bash
bitmark db
```


## Configuration Directory

bitmark stores YAML flag definition files in a .bitmark directory:

- Primary location: ~/.bitmark
- If home directory not found, uses .bitmark in the current working directory.


## Examples

Parse flags without a type:

```bash
bitmark 0x05
```

Output:

```
bit 0: 0x1
bit 2: 0x4

0x1 | 0x4
```

Create type:

```bash
bitmark create myflags READ=0x01 WRITE=0x02 EXECUTE=0x04
```

Parse flags with a type:

```bash
bitmark parse 0x05 myflags
```

Output:

```
bit 0: [READ] 0x1
bit 2: [EXECUTE] 0x4

READ | EXECUTE
```

.bitmark/myflags.yml structure:

```yaml
READ: '0x1'
WRITE: '0x2'
EXECUTE: '0x4'
```
ordered-enum 0.0.10
A small library for adding total orderings to enums
Requires Python: >=3.9

ordered_enum
============

[![CI](https://github.com/woodruffw/ordered_enum/actions/workflows/ci.yml/badge.svg)](https://github.com/woodruffw/ordered_enum/actions/workflows/ci.yml)
[![Downloads](https://pepy.tech/badge/ordered-enum)](https://pepy.tech/project/ordered-enum)

**ordered_enum** is a small library for adding (total) orderings to `enum.Enum`s.

It provides two ordering behaviors:

* `ordered_enum.OrderedEnum`: total ordering by definition
* `ordered_enum.ValueOrderedEnum`: "total" ordering by member values

## Installation

**ordered_enum** requires Python 3.9 or newer.

```bash
pip3 install ordered_enum
```

## Usage

To use **ordered_enum**, just use `OrderedEnum` or `ValueOrderedEnum` as your parent class:

```python
from ordered_enum import OrderedEnum


class State(OrderedEnum):
    Disabled = 4
    Loaded = 3
    Waiting = 2
    Running = 1
    Dead = 0


assert(State.Disabled < State.Loaded)
assert(sorted([State.Dead, State.Waiting]) == [State.Waiting, State.Dead])
```

`OrderedEnum` doesn't require `@enum.unique` (or unique values at all); it uses the order of
definition to impose an ordering between members.

If you'd like to impose an ordering based on member values, you can use `ValueOrderedEnum` instead:

```python
import enum
from ordered_enum import ValueOrderedEnum


@enum.unique
class State(ValueOrderedEnum):
    Disabled = 4
    Loaded = 3
    Waiting = 2
    Running = 1
    Dead = 0


assert(State.Disabled > State.Loaded)
assert(sorted([State.Waiting, State.Dead]) == [State.Dead, State.Waiting])
```

`ValueOrderedEnum` **does** require unique values, which can be enforced via `@enum.unique`.
Failing to make a `ValueOrderedEnum`'s values unique will result in a silently broken ordering.

## Caveats

As mentioned above, `ordered_enum.OrderedEnum` provides an ordering of enum values based on their order
of definition in the class. This means that:

1. Enum values doesn't have to be unique for **ordered_enum** to work
2. Enum values can be heterogeneously typed
2. Moving enum values around changes their ordering

Therefore, you should either not depend on a specific ordering **or** ensure that your
order of definition is the order you'd like.