semvec/pypi-packages huggingface dataset:
freder 0.0.3
FRED API Python package
Requires Python: >=3.9
Keywords: fredapi, fred, macroeconomics

# FRED API Usage facilitator

![main workflow](https://img.shields.io/github/actions/workflow/status/haydenkuk/fred/main.yaml?logo=github)
![GitHub licence](https://img.shields.io/pypi/l/fred?logo=github)
![GitHub downloads](https://img.shields.io/github/downloads-pre/haydenkuk/fred/latest/total?logo=github)
![documentation](https://img.shields.io/readthedocs/fred?logo=readthedocs)
![PyPi download](https://img.shields.io/pypi/dm/fred?logo=pypi)
![PyPi version](https://img.shields.io/pypi/v/fred?logo=pypi)
![python version](https://img.shields.io/pypi/pyversions/fred?style=pypi)


FRED API
(https://fred.stlouisfed.org/docs/api/fred/)

Features
- All API endpoints included according to the fred docs(https://fred.stlouisfed.org/docs/api/fred/)

1. Installation
```sh
pip install freder
```
Requires Python 3.9+

2. Usage

1-1) Authentication: using dotenv
 - Created a file named ".env"
 - Add "FRED_APIKEY='YOURAPIKEY'" in the file

1-2) Authentication: using "set_apikey"
```python
import freder

freder.set_apikey('yourapikey')
```

2) apicalls
```python
import freder

result = freder.get_category(0)
print(result)
```
All API endpoints are included in this package,
Please refer to https://fred.stlouisfed.org/docs/api/fred/
For more API endpoints

Also, Please pay attention to docstrings of each fred functions in this package. I included fred's explanation of each input variable to facilitate the process.
ping-game-theory-25 0.1.3
Driver Code for @ping/game-theory-25
Requires Python: >=3.9

This package contains simple driver code + testing functionality for @ping/game-theory-25

# Types


## `Move` (Enum)
```python
class Move(StrEnum):
    ROCK = "ROCK"
    PAPER = "PAPER"
    SCISSOR = "SCISSOR"
```
Represents a single move in the game.


## `HistoryEntry` (Dataclass)
```py
@dataclass
class HistoryEntry:
    self: Move
    other: Move
```
Represents the result of one round of play between two strategies.

| Field   | Type   | Meaning                            |
| ------- | ------ | ---------------------------------- |
| `self`  | `Move` | The move played by *this* strategy |
| `other` | `Move` | The move played by the opponent    |


## `History` (Type Alias)
```py
History = Tuple[HistoryEntry, ...]
```
A read-only sequence of all previous rounds. Each element is a `HistoryEntry`. The most recent round is at the **end** of the tuple.


## `Strategy` (Abstract Base Class)
```py
class Strategy(ABC):
    @abstractmethod
    def begin(self) -> Move:
        ...

    @abstractmethod
    def turn(self, history: History) -> Move:
        ...
```
Base class for all strategies (bots).
Every strategy must implement two methods:
| Method          | Called When                 | Purpose                                         |
| --------------- | --------------------------- | ----------------------------------------------- |
| `begin()`       | Before the first round      | Returns the first move                          |
| `turn(history)` | Every round after the first | Returns the next move based on previous history |

Any class that does **not** implement both methods cannot be instantiated.


# Example Strategy
```py
class ILoveRocks(Strategy):
    def __init__(self) -> None:
        self.author_netid = "lm742"
        self.strategy_name = "ILoveRocks"
        self.strategy_desc = "I really love rocks"

    def begin(self) -> Move:
        return Move.ROCK

    def turn(self, history: History) -> Move:
        return Move.ROCK
```

# Strategy Tester
To ensure every strategy follows the required interface and runs efficiently, the project includes a built-in tester: `StrategyTester`

The tester automatically checks:
| Check              | What it verifies                                         |
| ------------------ | -------------------------------------------------------- |
| **Initialization** | Your strategy's `__init__` runs without errors           |
| **Return types**   | `begin()` and `turn()` must always return a valid `Move` |
| **No exceptions**  | Your strategy must never crash during play               |
| **Performance**    | Must complete `10,000` rounds within `60 seconds`        |

If your strategy passess all checks, you will see:
```py
✅ PASS: 10000 rounds in X.XX seconds
```

## How to Test your Strategy
You must pass in your strategy class **without** instantiating it
```py
if __name__ == "__main__":
    tester = StrategyTester(ILoveRocks)
    tester.run()
```
p2f-hydrates 0.1.0.1
A package providing functionality for the simulation of equilibrium and inhibition of clathrate hydrates
Requires Python: >=3.8

# p2f_hydrates

A Python Library for the Prediction of Natural Gas Hydrate Equilibrium and Inhibition. Developed by Karsten Kunneman in collaboration with Prof. Amadeu K. Sum at the Colorado School of Mines

Version 0.1.0.1 - 2025/11/05

This tool is designed to determine the equilibrium conditions for a given single- or multiple-component hydrate system, including systems in the presence of inhibitors (alcohols, glycols, and salts).

This tool is based primarily on the following models:

- Phase behavior of clathrate hydrates: a model for single and multiple gas component hydrates by J. B. Klauda and S. I. Sandler [doi: 10.1021/ie000322b]
- Universal correlation for gas hydrates suppression temperature of inhibited systems: III. salts and organic inhibitors by Y. Hu, J.-H. Sa, B. R. Lee, and A. K. Sum [doi: 10.1002/aic.16369]
For Questions, Suggestions, or Bug Reports, please contact Prof. Amadeu K. Sum: asum@mines.edu

To cite this library, please cite:
p2f-hydratecalc: A web Python-based tool for the prediction of natural gas hydrate equilibrium and inhibition by Karsten Kunneman and Amadeu K. Sum [doi: 10.1016/j.softx.2025.102422]

For Questions, Suggestions, or Bug Reports, please contact Prof. Amadeu K. Sum: asum@mines.edu

Disclaimer: The model and predictions have been tested and verified to be accurate based on extensive comparison with available literature data. However, this web app is provided "as is" and "as available" without any warranties of any kind, either express or implied, including, but not limited to, implied warranties of use, merchantability, fitness for a particular purpose, and non-infringement.

©2025, All Rights Reserved Full source code available at https://github.com/karstenkunneman/p2f_hydrates This work is licensed under the Creative Commons Attribution-ShareAlike 4.0 International License. To view a copy of this license, visit https://creativecommons.org/licenses/by-sa/4.0/.
sparq 0.2.6
Python client for the sparq api - automated degree planning for SJSU students + more
Requires Python: >=3.8

# sparq Client

Python client library for the sparq API - automated degree planning for SJSU students.

## Installation

```bash
pip install sparq
```

## Quick Start

### 1. Get Your API Key

First, register and get your API key:

```bash
sparq auth
```

This will:
- Send a verification code to your email
- Generate your API key after verification
- Save it to `~/.sparq/config.txt`

### 2. Generate a Degree Plan

Use the example script to test the API:

```bash
python sparq.py
```

Or use it in your own code:

```python
from sparq import Sparq

# Initialize with your API key (automatically loaded from config)
client = Sparq()

# Generate a degree plan
plan = client.plan(
	major="Computer Science",
	cc_courses=[{"code": "COMSC 075", "title": "Computer Science I", "grade": "A", "institution": "Evergreen Valley College"}],
	units_per_semester=15,
	schedule_preferences={"avoid_hours": ["8:00 AM", "8:00 PM"]}
)

print(plan)

# Get available class sections (no API key required)
sections = client.classes("CS 49J")
print(f"Found {len(sections['CS 49J'])} sections for CS 49J")

# Get sections for multiple courses
sections = client.classes(["CS 49J", "MATH 42", "CS 146"])
for course_id, course_sections in sections.items():
	print(f"{course_id}: {len(course_sections)} sections")
	for section in course_sections:
		print(f"  - {section['Section']}: {section['Instructor']}, {section['Days']} {section['Times']}")
```

### 3. Check Your API Usage

View your API usage statistics:

```bash
sparq usage
```

### 4. Recover Lost API Key

If you lose your API key:

```bash
sparq recover
```

### 5. Get Class Sections

Search for available class sections for any SJSU course (no API key required):

```bash
sparq classes
```

This will prompt you to enter course ID(s) and display all available sections with details like:
- Instructor
- Days and times
- Location
- Open seats
- And more

## CLI Commands

- `sparq auth` - Register and get your API key
- `sparq usage` - View API usage statistics
- `sparq recover` - Recover your API key via email
- `sparq classes` - Get available class sections for courses (no API key required)

## Features

- **Degree Planning**: Generate semester-by-semester plans for SJSU majors
- **Transfer Credit**: Support for community college and AP credits  
- **Usage Tracking**: Monitor your API calls and history
- **API Key Recovery**: Recover lost API keys via email verification

## Updates
For updates please visit: https://github.com/shiventi/sparq/blob/main/docs/documentation.md

## Support

For issues or questions, visit: https://github.com/shiventi/sparq