semvec/pypi-packages huggingface dataset:
ucsc-cse40 0.13.0
Dependencies for UCSC's CSE 40 - ML Basics: Data Analysis and Empirical Methods
Requires Python: >=3.8
Keywords: grading

# UCSC CSE 40

Materials for UCSC's CSE 40 course taught by Dr. Lise Getoor and managed by the [LINQS lab](https://linqs.org/).
This package is available on PyPi at [ucsc-cse40](https://pypi.org/project/ucsc-cse40/).

## Dependencies

This package is meant to be the sole direct dependency for CSE 40 students.
Instead of specifying each dependency for students, this package defines the necessary dependencies to be installed along with it.
So if you install this package (e.g. via pip), then it will also install all the necessary Python package dependencies for the course.

## Working with the Autograder

All interfacing with the autograder is done via the [autograder-py](https://pypi.org/project/autograder-py/) package.
You should refer to [the documentation](https://github.com/eriq-augustine/autograder-py) for information on how to use it.
typed-macro 0.1.16
Use procedural macros with type annotations in Python
Requires Python: >=3.12

# Typed macros in Python

**Status**: like really early pre-alpha

Inspired by Rust procedural macros, this package creates a macro system for Python. You can define a macro by writing a function that accepts a string of code and returns another string of code.

Your expanded macro is written to a `__macro__` file in the same directory, and automatically imported.

You don't need to add another build step, just run your code as normal. As soon as it runs, your IDE and type checker will start to pass.

> Note: ideally, you should load your module on every save, so that you get better IDE support when using macros. That part's sort of optional, but for my small projects, it's been handy.

## Why would I want this?

Python is a dynamic language, so you can technically do anything... if you don't care about type hinting. But if you're a sane person, then you *must* care about type hinting, and therefore you might care about macros 😛 

I like to think of Python as:
* runtime code can talk to runtime code (normal)
* type checking code can talk to type checking code (normal)
* type checking code can talk to runtime code (e.g. dataclasses)
* ...but runtime code can't talk to type hinting code

^ macros fill the gap on that last missing step


### Example use cases

* If you have a decorator that's impossible to fit with type hints (python generics are nowhere near as powerful as typescript generics, for example); make it a macro instead!
  * E.g. you want to [Concatenate](https://docs.python.org/3/library/typing.html#typing.Concatenate) a kwarg to a paramspec, but it only supports positional arguments
* If you want to modify the behavior of Python code at runtime
  * E.g. you want to build a system where if/else statements are eager evaluated rather than lazy evaluated
* If you have some auto-generated code and you want to auto-generate some type-safe code on top of it
  * E.g. you want to add extra methods to the OpenAPI spec objects that were previously generated

## Differences from Rust

* Rust puts your code inline, this package puts it in a separate file. So you can't automatically use things from the outer scope unless you specify them in the macro.
* Rust macros deal with syntax trees, but this package lets you parse the code yourself; sometimes the formatting of your python code could be important -- it's up to you whether you parse the AST or just do basic string manipulation.
yummyanime 0.0.9
Yummy Anime API wrapper
Requires Python: >=3.9

# YummyAnime API python

This is a wrapper around [yummyanime API](https://yummyani.me/api), written in Python async.

# Installation
```bash
pip install yummyanime
#OR using git
pip install git+https://github.com/IM1corp/YummyAPI
#OR using aur (on arch)
yay -S python-yummyanime
```

# Getting started
Before using the API, create DEV application [here](https://yummyani.me/dev/applications).

After that, start using it right away:

```python
import asyncio
from yummyanime import YummyApi, Format

api = YummyApi("your_client_id from https://yummyani.me/dev/applications", Format.JSON)


async def main(url: str):
    anime = await api.anime.get(url, need_videos=True)
    print("Friren's anime title: ", anime.response.title)
    video_kodik = next(i for i in anime.response.videos if "kodik." in i.iframe_url)
    qualities = await video_kodik.qualities(anime.response)
    print("Link to 720p: ", qualities.p720)

asyncio.run(main('provozhayushchaya-posledniy-put-friren'))
```
deepclimate 0.1.3
A deep learning framework for climate modelling and data analysis
Requires Python: >=3.9

# **DeepClimate**

*A Python package for climate modelling and data analysis with deep learning.*

**Latest Version:** 0.1.0
**Status:** Alpha

## **Description** 

[**DeepClimate**](https://pypi.org/project/deepclimate) is an intuitive Python library designed to simplify the training and evaluation of deep neural networks tailored for climate science. Whether you're working on emulation, downscaling, or bias correction of climate datasets, DeepClimate offers tools and pre-built deep learning models to accelerate your research and applications.

# Installing the package
```bash
pip install deepclimate
```

## **Features**  
- Built-in support for state-of-the-art deep learning architectures and training strategies (e.g., CNN, U-Net, GAN, etc.).  
- Custom loss functions for climate modeling and other climate-specific metrics.  
- Tools for data preprocessing, visualization, and evaluation.    

### **Objectives:**
1. Easy-to-use interface for novice users.
2. Develop a deep learning framework for training deep learning models with climate data.
3. Create custom modules for physics-informed training of deep learning models.
4. Custom training loss functions and evaluation metrics related to the climate science community.
5. An open library to host deep learning architectures from the literature.

### **Applications:**
- Climate data downscaling and bias-correction
- Weather/Climate prediction models.
- Hydro-meteorological research.
- Climate data analysis

### **Basic usage**

```python
# Import library modules
from deepclimate.tensorflow.train import ModelTraining
from deepclimate.tensorflow.models import LinearDense

# Load training and validation data
X_train, y_train = ...                # Prepare the training dataset (numpy array)
X_val,   y_val   = ...                # Prepare the validation dataset (numpy array)

model = LinearDense(...)             # Construct the model architecture

# Initialize the ModelTraining class with specified parameters
mt = ModelTraining(
    generator = model,                # Generator architecture (model) to be used
    loss_fn   = 'loss',               # Loss function for training 
    lr_init   = 0.0001,               # Initial learning rate for the optimizer
    )

# Train the model using the specified training and validation data, and other parameters
mt.train(
    train_data = (X_train, y_train),  # Training data (input features and target labels)
    val_data   = (X_val, y_val),      # Validation data (input features and target labels)
    epochs     = int,                  # Number of epochs to train the model (can be adjusted)
    batch_size = int,                  # Batch size for training and validation
    )
```

### **IMPORTANT NOTE**
- The package is under development. Stay connected.