semvec/pypi-packages huggingface dataset:
pyculus 0.0.12
a collection of calculus-related functions
Requires Python: >=3.7

# **pyculus - A Python Library for Calculus Operations**

## **📌 Overview**
pyculus is a Python library that provides **calculus-related functions** including:
- **Simplification of expressions**
- **Domain determination**
- **Derivative calculations**
- **Finding critical points**
- **Table of variations**
- **Increasing and decreasing intervals**
- **Graph plotting**

This library is built using **SymPy, NumPy, and Matplotlib**, making it useful for both **symbolic mathematics** and **visualization**.

---

## **🚀 Installation**
You can install pyculus using pip:
```sh
pip install pyculus
```

---

## **🔹 Usage**
### **1️⃣ Import the Library**
```python
import pyculus as fn
```

### **2️⃣ Define a Function**
```python
f = x**4 - 2*x**2
```

### **3️⃣ Simplify the Function**
```python
simplified = fn.symplify(f)
print(simplified)
```

### **4️⃣ Find the Domain**
```python
d = fn.domain(f)
print("Domain:", d)
```

### **5️⃣ Compute the Derivative**
```python
derivative = fn.derivative(f)
print("Derivative:", derivative)
```

### **6️⃣ Find Critical Points**
```python
critical_pts = fn.critical_points(f)
print("Critical Points:", critical_pts)
```

### **7️⃣ Generate the Table of Variations**
```python
table = fn.table(f)
print("Table of Variations:", table)
```

### **8️⃣ Find Extreme Points**
```python
extreme_pts = fn.extreme(f)
print("Extreme Points:", extreme_pts)
```

### **9️⃣ Identify Increasing and Decreasing Intervals**
```python
increasing_intervals = fn.increasing(f)
decreasing_intervals = fn.decreasing(f)
print("Increasing Intervals:", increasing_intervals)
print("Decreasing Intervals:", decreasing_intervals)
```

### **🔟 Plot the Function**
fn.graph(f)
```

---

## **📌 Features**
- **Symbolic Computation:** Uses SymPy for mathematical operations.
- **Automatic Domain Calculation:** Handles function continuity.
- **Calculus Tools:** Finds derivatives, critical points, and variation tables.
- **Graphing Support:** Uses Matplotlib for visualizing functions.
- **Numerical Handling:** Leverages NumPy for better numerical processing.
- **As of now, the library is not able to take into account discontinuities in the calculations of the increasing and decreasing intervals - but this will not cause an error in the graph.

---

## **🛠 Dependencies**
Function requires the following libraries:
- `sympy`
- `numpy`
- `matplotlib`

These will be installed automatically with `pip install function`.

---

## **📄 License**
This project is licensed under the **GNU General Public License v3.0 (GPL-3.0)**. See the [LICENSE](LICENSE) file for details.

---

## **📞 Contact**
For any questions, bug reports, or feature requests, send an email:
pythonfunctionslibrery@gmail.com

Happy coding! 🚀
pythainance 0.0.7
AI financial analysis library for Thai financial data
Requires Python: >=3.7

# PyThainance

![PyThainance](https://img.shields.io/badge/Thai-Finance-blue.svg)  
📊 **The Next-Gen Thai Financial Data Library** 🚀

PyThainance is an **open-source financial analysis library** designed to simplify working with **Thai public debt, macroeconomic data, and state enterprise debt**. Built for researchers, policymakers, and developers, PyThainance provides a powerful toolkit for financial data analysis, forecasting, and visualization.

## 📦 Installation

Install via PyPI (Coming Soon!):
```bash
pip install pythainance
```

## 🚀 Quick Start

```python
from pythainance import *

# Load Thailand's debt dataset
debt = get_debt_data()

# Visualize the trend over time
plot_public_debt_composition(debt)
plot_debt_gdp(debt)
plot_covid_debt_impact(debt)
plot_foreign_debt_and_exchange(debt)
plot_debt_guarantee_status(debt)
plot_debt_metrics_correlation(debt)
plot_debt_gdp_with_crisis(debt)
plot_debt_service_heatmap(debt)
```

## ⚖️ License

PyThainance is released under the **MIT License**, allowing both personal and commercial use. See the **[LICENSE](https://opensource.org/licenses/MIT)** file for more details.

---

💡 **Follow us for updates!** 🚀
airflow-slurm-executor 0.0.9
Plugin for Airflow to connect to slurm clusters
Requires Python: >=3.6

[![PyPI](https://img.shields.io/pypi/v/airflow-slurm-executor)](https://pypi.org/project/airflow-slurm-executor/)
[![PyPI - Downloads](https://img.shields.io/pypi/dm/airflow-slurm-executor)](https://pypi.org/project/airflow-slurm-executor/)

# Slurm Executor

The Slurm executor is based on work done by Hanno Holties in https://git.astron.nl/eosc/slurmexecutorplugin, this one 
extends the use of parameters to be passed to the Slurm cluster so one can control the partition, the account, and other
details about the jobs submission.

It was changed from **srun** to **sbatch** as a default command to interact with the cluster, so multiple jobs can be 
submitted at a time.


To use the plugin after installing the package change
the AIRFLOW configuration file as such:
```
# The executor class that airflow should use. Choices include
# SequentialExecutor, LocalExecutor, CeleryExecutor, DaskExecutor, KubernetesExecutor
executor = airflow_slurm_executor.SlurmExecutor
```

## Custom Use

One can pass the **executor_config** parameter in the default_args attribute to any DAG to customize some aspects of the
job.
```
with DAG(
    dag_id="my_dag",
    start_date=pendulum.datetime(2016, 1, 1),
    schedule="@daily",
    default_args={"executor_config": {"SlurmExecutor: {"attribute": "value"}},
                  "queue": "QUEUE"},
):
```

The **QUEUE** parameter defined as default argument will be translated as the partition to be used by slurm.
qneura 0.0a0
Open Source Pakcage for Solving Quantum Many-body problems via Neural network quantum states
Requires Python: >=3.8

# QNeura

![qneura logo](https://github.com/ares201005/qneura/blob/HEAD/docs/static/logo_tbd.png?raw=true)

[![Documentation Status](https://readthedocs.org/projects/qneura-lmi/badge/?version=develop)](https://qneura-lmi.readthedocs.io/en/develop/?badge=develop)
[![GitHub release](https://img.shields.io/github/release/ares201005/qneura/all.svg)](https://github.com/ares201005/qneura/releases)
[![Build Status](https://github.com/ares201005/qneura/actions/workflows/ci.yml/badge.svg)](https://github.com/ares201005/QNeura/actions?query=workflow%3ACI)
[![codecov](https://codecov.io/gh/ares201005/QNeura/graph/badge.svg?token=2CBUTFR93Y)](https://codecov.io/gh/ares201005/QNeura)


[`qneura`](https://github.com/ares201005/qneura):  Open Source Pakcage for Solving Quantum Many-body problems via Neural network quantum states.

-----------------------------------------------


## LANL-C23019

TBA.

## Authors:

[Yu Zhang](mailto:zhy@lanl.gov)

## Features:
szcore-evaluation 0.0.7
Compare szCORE compliant annotations of EEG datasets of people with epilelpsy.
Requires Python: >=3.12

# szcore-evaluation

Compare szCORE compliant annotations of EEG datasets of people with epilelpsy.

The package compares annotations in TSV. The annotations should be organized in a BIDS compliant manner:

```txt
BIDS_DATASET/
├── ...
├── sub-01/
│   ├── ses-01/
│   │   └── eeg/
│   │       ├── sub-01_ses-01_task-szMonitoring_run-00_events.tsv
│   │       ├── ...
│   ├── ...
├── ...
```

The package compares hypothesis annotations to reference annotations from two folders which follow the same structure. It provides a JSON file with the overall results as an output:

```json
{
  "sample_results": {
    "sensitivity": 0.08,
    "sensitivity_std": 0.04,
    "precision": 0.01,
    "precision_std": 0.01,
    "f1": 0.02,
    "f1_std": 0.01,
    "fpRate": 9792.41,
    "fpRate_std": 4566.68
  },
  "event_results": {
    "sensitivity": 1.0,
    "sensitivity_std": 0.0,
    "precision": 0.08,
    "precision_std": 0.03,
    "f1": 0.16,
    "f1_std": 0.04,
    "fpRate": 280.55,
    "fpRate_std": 0.03
  }
}
```

The library provides a simple interface:

```python
def evaluate_dataset(
    reference: Path, hypothesis: Path, outFile: Path, avg_per_subject=True
) -> dict:
    """
    Compares two sets of seizure annotations accross a full dataset.

    Parameters:
    reference (Path): The path to the folder containing the reference TSV files.
    hypothesis (Path): The path to the folder containing the hypothesis TSV files.
    outFile (Path): The path to the output JSON file where the results are saved.
    avg_per_subject (bool): Whether to compute average scores per subject or
                            average across the full dataset.

    Returns:
    dict. return the evaluation result. The dictionary contains the following
          keys: {'sample_results': {'sensitivity', 'precision', 'f1', 'fpRate',
                    'sensitivity_std', 'precision_std', 'f1_std', 'fpRate_std'},
                 'event_results':{...}
                 }
    """
```