semvec/pypi-packages huggingface dataset:
scout-cli 0.11.0
A modern, intuitive alternative to ls command with smart directory prediction
Requires Python: >=3.7

# Scout CLI

A modern, intuitive alternative to `ls` and `cd` commands with smart directory prediction.

## Installation

1. Install via pip:
```bash
pip install scout-cli
```

2. Set up shell integration:
```bash
# Add to your ~/.bashrc or ~/.zshrc:
source "$(pip show scout-cli | grep Location | cut -d' ' -f2)/scout/share/scout/scout.sh"
```

## Features

- Smart directory navigation with fuzzy matching
- Modern, colorful file listings
- Bookmark management for frequently used directories
- AI-powered directory suggestions
- Project root detection
- Time-based suggestions

## Usage

### List Files (replaces ls)
```bash
scout                    # List files in current directory
scout -a                 # Show hidden files
scout --sort size       # Sort by file size
scout --sort modified   # Sort by modification time
scout --sort name       # Sort by name (default)
```

### Directory Navigation (replaces cd)
```bash
scout jump <dir>        # Smart jump to directory
scout jump -            # Go back to previous directory
scout jump docs -c      # Create 'docs' directory and jump to it
scout jump old-dir -d   # Delete directory (with confirmation)
scout jump old-dir -d -f # Force delete without confirmation
```

### Bookmark Management
```bash
scout jump --save       # Save current directory as bookmark
scout jump --bookmarks  # List saved bookmarks
scout jump <bookmark>   # Jump to bookmarked directory
```

## Smart Features

- **Fuzzy Matching**: Type partial names, scout finds matches
- **AI Suggestions**: Scout learns from your navigation patterns
- **Context Aware**: Suggests based on time and location
- **Project Detection**: Recognizes project directories

## Development

1. Clone the repository
2. Install development dependencies:
```bash
make dev-setup
```

3. Run tests:
```bash
make test
```

4. Build and install locally:
```bash
make install
```

## License

MIT License
CryptoBotSyncApi 1.0.1
Simple python library for CryptoBot (service CryptoPay) API
Requires Python: >=3.10.0

![](static/header.svg)
<p align="center">
    <a href="#">
        <img src="https://img.shields.io/github/license/artcher19/CryptoBotSyncApi?style=flat-square" />
    </a>
    <a href="https://t.me/send?start=r-2buqm">
        <img src="https://img.shields.io/badge/telegram-group-blue?style=flat-square&logo=telegram" />
    </a>
    <a href="#">
        <img src="https://img.shields.io/github/stars/artcher19/CryptoBotSyncApi?style=social" />
    </a>
</p>

# Overview
This is a simple sync Python library for API [@CryptoBot](https://t.me/send?start=r-2buqm) particularly payment service CryptoPay.

Check official API documentation: https://help.crypt.bot/crypto-pay-api

---
# Installation
```sh
pip install CryptoBotSyncApi
```
---
# First Steps
1. Create your application and get an API token:
Open [@CryptoBot](https://t.me/send?start=r-2buqm) or [@CryptoTestnetBot](http://t.me/CryptoTestnetBot) (for testnet).
2. Send bot a command `/pay` to create a new app and get API Token.
3. Copy API token
4. Use your API token to create CryptoPay object
>All queries to the Crypto Pay API must be sent over HTTPS
---
# Example
```
from CryptoBotSyncApi import CryptoPay

pay = CryptoPay("crypto_bot_api")
invoice = pay.create_invoice(amount='500', currency_type='fiat', accepted_assets='usdt,btc', fiat='RUB')
```
---
# Methods
- get_me() - Use this method to test your app's authentication token. Requires no parameters.
- create_invoice() - Use this method to test your app's authentication token. Requires no parameters.
- delete_invoice - Use this method to delete invoices created by your app.
- create_check - Use this method to create a new check.
- delete_check - Use this method to delete checks created by your app.
- transfer - Use this method to send coins from your app's balance to a user. This method must first be enabled in the security settings of your app. Open @CryptoBot (@CryptoTestnetBot for testnet), go to Crypto Pay → My Apps, choose an app, then go to Security -> Transfers... and tap Enable.
- get_invoices() - Use this method to get invoices created by your app.
- get_transfers() - Use this method to get transfers created by your app.
- get_checks() - Use this method to get checks created by your app.
- get_balance() - Use this method to get balances of your app. Requires no parameters.
- get_exchange_rates() - Use this method to get exchange rates of supported currencies. Requires no parameters.
- get_currencies() - Use this method to get a list of supported currencies. Requires no parameters.
- get_stats() - Use this method to get app statistics.
---
# Creator
Library developed by [@Artcher](https://t.me/artcher_news).

I will be 😊 very thankful if you use my ref [link](https://t.me/send?start=r-2buqm) to register in CryptoBot
requisite-check 0.1.0
Module for working with course requisite data and checking requisite satisfaciton.
Requires Python: <4.0,>=3.10

# Requisite Processor
The `RequisiteProcessor` class is designed to evaluate whether the prerequisite rules for a course are met given a list of completed courses and test score data.

## Prerequisite Data
This module can make use of any arbitrary prerequisite information given that it is formatted correctly. For more information on the necessary structure as well as the latest prerequsite data for UNM courses, see this repo:

https://lobogit.unm.edu/unm-data-analytics/requisite-data#

## Usage

### Initialization
Initialize the RequisiteProcessor with a dictionary of prerequisite rules.

```python
from requisite_processor import RequisiteProcessor

prerequisite_rules = {
    "202310": {
        "MATH 1512": {
            "type": "course",
            "course": {"code": "MATH 1234"},
            "minimum_course_grade": "C"
        }
    }
}

processor = RequisiteProcessor(prerequisite_rules)
```

### Processor Methods
The RequisiteProcessor contains the following methods:
*availabile_academic_periods*:
Returns a list of all academic periods in the dataset.
```python
academic_periods = processor.availabile_academic_periods
print(academic_periods)  # Output: ['202310', '202380']
```

*latest_available_academic_period*:
Returns the most recent academic period.
```python
latest_period = processor.latest_available_academic_period
print(latest_period)  # Output: '202380'
```

*check_satisfaction*:
Checks if a student satisfies the prerequisites for a course in a specific academic period.

Parameters:

- course_code (str): Course to check prerequisites for.
- courses_taken (list[dict], optional): List of completed courses and grades. Defaults to [].
- test_scores (dict, optional): Test scores dictionary. Defaults to {}.
- academic_period (str, optional): Academic period. Defaults to the latest available.
- ignore_tests (bool, optional): Ignore test requirements. Defaults to False.
- ignore_grades (bool, optional): Ignore grade requirements. Defaults to False.

Returns:
RequisiteCheckResult object. The result of the prerequisite check.

See below for example usage.

### Example Prerequisite Satisfaction Check

```python
courses_taken = [{"code": "MATH 1250", "grade": "B"}]
test_scores = {"A01": 28}

result = processor.check_satisfaction(
    course_code="MATH 1512",
    courses_taken=courses_taken,
    test_scores=test_scores
)

print(result.satisfied)  # Output: True or False
```

## Future Work
- Write tests
- Allow for more customization in how requisites are processed.
- Write additional helper functions such as string representation of requirements, flattend requirements and more.