semvec/pypi-packages huggingface dataset:
uplc 1.3.2
Python implementation of untyped plutus language core
Requires Python: <4.0,>=3.9
Keywords: cardano, compiler, language, programming-language, python, smart-contracts, validator

Untyped Plutus Language Core 
==================================================
[![CI/CD](https://github.com/OpShin/uplc/actions/workflows/build.yml/badge.svg)](https://github.com/OpShin/uplc/actions/workflows/build.yml)
 [![PyPI version](https://badge.fury.io/py/uplc.svg)](https://pypi.org/project/uplc/)
 ![PyPI - Python Version](https://img.shields.io/pypi/pyversions/uplc.svg)
 [![PyPI - Status](https://img.shields.io/pypi/status/uplc.svg)](https://pypi.org/project/uplc/)
[![Coverage Status](https://coveralls.io/repos/github/OpShin/uplc/badge.svg?branch=master)](https://coveralls.io/github/OpShin/uplc?branch=master)

This is a basic library to support creating and manipulating programs written in [UPLC](https://blog.hachi.one/post/an-introduction-to-plutus-core/).

## Installation

Install Python 3.9 or higher and make sure you have `pip` installed.
Then run

```bash
pip install uplc
```

### Secp256k1

If you want to use the builtin functions for verification of ECDSA and Schnorr signatures,
follow the instructions to install `libsecp256k1` with schnorr support enabled. We provide a script to do this for you on Linux and MacOS.

```bash
curl -sSL https://raw.githubusercontent.com/OpShin/uplc/refs/heads/master/install_secp256k1.sh | bash
```


This makes sure that the exact same version is used that is used in the `cardano-node`.
Then, install the python bindings for `secp256k1` with

```bash
pip install python-secp256k1-cardano
```

## Usage

This tool may be used to parse, reformat (/dump), evaluate or build contract artifacts from UPLC code.

```bash
# Check validity of a source file
uplc parse examples/fibonacci.uplc

# Dump a source file in either the official plutus or legacy aiken dialect
uplc dump examples/fibonacci.uplc --dialect plutus --unique-varnames
uplc dump examples/fibonacci.uplc --dialect legacy-aiken

# Evaluate a UPLC program on UPLC input
uplc eval examples/fibonacci.uplc "(con integer 5)"

# Build smart contract artifacts from the UPLC program
uplc build examples/fibonacci.uplc

# This package can also be used to analyze built contracts (output from any Smart Contract Language)
uplc dump build/fibonacci/script.cbor --from-cbor

# You can also apply additional parameters to a script using the build command
uplc build script.cbor --from-cbor "(con integer 5)"

# Show all options
uplc --help
```

## Running tests

To run the testsuite of UPLC, use `pytest`.
```
pytest
```


## Scope and Contributions
This is a side product of the development of a pythonic smart contract language for the Cardano blockchain
and hence much tailored to the needs of that development.

Most likely it *can* do what you would like to do but its not properly documented. Please do reach out via Discord or GitHub issue if you think this tool could be of use to you.

Contributions are very welcome.
icet 3.2
A Pythonic approach to cluster expansions
Requires Python: >=3.9
Keywords: chemistry, physics, scientific

icet
====

**icet** is a tool for the construction and sampling of alloy cluster expansions.
A detailed description of the functionality provided as well as an extensive tutorial can be found in the `user guide <https://icet.materialsmodeling.org/>`_.

**icet** is written in Python, which allows easy integration with countless first-principles codes and analysis tools accessible from Python, and allows for a simple and intuitive user interface.
All computationally demanding parts are, however, written in C++ providing performance while maintaining portability.
The following snippet illustrates how one can train a cluster expansion:

.. code-block:: python

   cs = ClusterSpace(primitive_cell, cutoffs, species)
   sc = StructureContainer(cs)
   for structure in training_structures:
       sc.add_structure(structure)
   opt = Optimizer(sc.get_fit_data())
   opt.train()
   ce = ClusterExpansion(cs, opt.parameters)

Afterwards the cluster expansion can be used, e.g., for finding ground state structures or sampled via Monte Carlo simulations.

For questions and help please use the `icet discussion forum on matsci.org <https://matsci.org/icet>`_.
**icet** and its development are hosted on `gitlab <https://gitlab.com/materials-modeling/icet>`_.


Installation
------------

**icet** can be installed using `pip <https://pypi.org/project/icet/>`_::

    pip3 install icet --user

or via `conda <https://anaconda.org/conda-forge/icet>`_::

    conda install -c conda-forge icet

Installation via `pip` requires a C++11 compliant compiler.
Please consult the `installation section of the user guide <https://icet.materialsmodeling.org/installation.html>`_ for details.

**icet** is based on Python3 and invokes functionality from other Python libraries including
`ase <https://wiki.fysik.dtu.dk/ase>`_,
`pandas <https://pandas.pydata.org/>`_,
`numba <https://numba.pydata.org/>`_,
`numpy <http://www.numpy.org/>`_,
`scipy <https://www.scipy.org/>`_,
`spglib <https://atztogo.github.io/spglib/>`_, and
`trainstation <https://trainstation.materialsmodeling.org/>`_.


Credits
-------

**icet** has been developed at the `Department of Physics <https://www.chalmers.se/en/departments/physics/Pages/default.aspx>`_ of `Chalmers University of Technology <https://www.chalmers.se/>`_ (Gothenburg, Sweden) and the `Data and Software Management Center <https://europeanspallationsource.se/data-management-software>`_ at the European Spallation Source (Copenhagen, Denmark).

When using **icet** in your research please cite

| M. Ångqvist, W. A. Muñoz, J. M. Rahm, E. Fransson, C. Durniak, P. Rozyczko, T. H. Rod, and P. Erhart
| *ICET – A Python Library for Constructing and Sampling Alloy Cluster Expansions*
| Adv. Theory. Sim., 1900015 (2019)
| `doi: 10.1002/adts.201900015 <https://doi.org/10.1002/adts.201900015>`_

Also consult the `credits <https://icet.materialsmodeling.org/credits>`_ page of the documentation for additional references.
fink-anomaly-detection-model 0.4.82
Fink SNAD Anomaly Detection Model
Requires Python: >=3.9

# Fink anomaly detection model

Здесь пока куча косяков, в обозримом будущем постараюсь их поправить

A set of modules for training models for finding anomalies in photometric data. There are currently two entry points via the console: _fink_ad_model_train_ and _get_anomaly_reactions_.

##  fink_ad_model_train

The module trains the AADForest model using expert reactions from the C055ZJJ6N2AE channels in Slack and -1001898265997 in Telegram. It creates the following files:
- _g_means.csv and _r_means.csv -- averages over the training dataset;
- _reactions_g.csv and _reactions_r.csv -- training datasets for additional training of the AADForest algorithm, based on expert reactions from Slack and Telegram channels;
- forest_g_AAD.onnx -- model for _g filter
- forest_r_AAD.onnx -- model for _r filter

**optional arguments:**

  --dataset_dir DATASET_DIR
                        Input dir for dataset (default: './lc_features_20210617_photometry_corrected.parquet')
						
  --n_jobs N_JOBS       
						Number of threads (default: -1)


**usage**: fink_ad_model_train [-h] [--dataset_dir DATASET_DIR] [--n_jobs N_JOBS]


## get_anomaly_reactions



Uploading anomaly reactions from messengers. It creates the following files:
- _reactions_g.csv and _reactions_r.csv -- training datasets for additional training of the AADForest algorithm, based on expert reactions from Slack and Telegram channels;



**optional arguments:**

  --slack_channel SLACK_CHANNEL
                        Slack Channel ID (default: 'C055ZJJ6N2AE')
  
  --tg_channel TG_CHANNEL
                        Telegram Channel ID (default: -1001898265997)

**usage**: get_anomaly_reactions [-h] [--slack_channel SLACK_CHANNEL]
                             [--tg_channel TG_CHANNEL]
edupage-api 0.12.3
A Python library for accessing your EduPage account
Requires Python: >=3.9
Keywords: edupage, edupage api, library

# `edupage-api` &middot; [![Current version on PyPI](https://img.shields.io/pypi/v/edupage-api)](https://pypi.org/project/edupage-api/) [![Supported Python versions](https://img.shields.io/pypi/pyversions/edupage-api)](https://pypi.org/project/edupage-api/) [![PyPI - Downloads](https://img.shields.io/pypi/dw/edupage-api)](https://pypistats.org/packages/edupage-api) [![CodeFactor](https://www.codefactor.io/repository/github/EdupageAPI/edupage-api/badge)](https://www.codefactor.io/repository/github/EdupageAPI/edupage-api)

This Python library allows easy access to EduPage. It's not a Selenium web scraper. It makes requests directly to EduPage's endpoints and parses the HTML document.

# Installing
__Warning__: Requires Python >= 3.9!

You can install this library using [`pip`](https://pypi.org/project/pip/):

```
pip install edupage-api
```

# Usage

## Login

You can log in easily, it works with any school:

```python
from edupage_api import Edupage
from edupage_api.exceptions import BadCredentialsException, CaptchaException

edupage = Edupage()

try:
    edupage.login("Username", "Password", "Your school's subdomain")
except BadCredentialsException:
    print("Wrong username or password!")
except CaptchaException:
    print("Captcha required!")
```

# Documentation
The docs are available [here](https://edupageapi.github.io/edupage-api/)

# I have a problem or an idea!

- If you find any issue with this code, or it doesn't work please, let us know by opening an [issue](https://github.com/EdupageAPI/edupage-api/issues/new/choose)!
- Feel free to suggest any other features! Just open an [issue with the _Feature Request_ tag](https://github.com/EdupageAPI/edupage-api/issues/new?labels=feature+request&template=feature_request.md&title=%5BFeature+request%5D+).
- If you, even better, have fixed the issue, added a new feature, or made something work better, please, open a [pull request](https://github.com/EdupageAPI/edupage-api/compare)!

# Discord
https://discord.gg/fg6zBu9ZAn
pyplaces 0.4.6
pyplaces is a Python package meant to streamline the usage of large places datasets, notably Overture Maps and Foursquare Open Places. All of the datasets and past releases can be downloaded to a specific address, place or bounding box. Conventionally, users download the data themselves or use a tool such as DuckDB to download what they need, whereas pyplaces is more integrated, faster, and more precise.
Requires Python: >=3.10

# pyplaces

**pyplaces is still in development, so if you run into any bugs please report them [here](https://github.com/tbanken/pyplaces/issues)**

**pyplaces** is a Python package meant to streamline the usage of large places datasets, notably Overture Maps and Foursquare Open Places. All of the datasets and past releases can be downloaded to a specific address, place or bounding box. Conventionally, users download the data themselves or use a tool such as DuckDB to download what they need, whereas pyplaces is more integrated, faster, and more precise. 

## Quickstart

### Installation

This package is available on PyPI as well as conda-forge:

    pip install pyplaces

    conda install pyplaces

I recommend that you use Anaconda for your Python environments. (I use miniforge and mamba)

### Basic Usage

To access any places, all you need is a place, address, or bounding box:

    from pyplaces.foursquare_open_places import foursquare_places_from_address

    hemenway_st_places = foursquare_places_from_address("204 Hemenway Street, Boston, MA")

Additionally, you can:
- [Select and filter on columns](https://pyplaces.readthedocs.io/en/latest/usage.html#filters)
- [Get data from past releases](https://pyplaces.readthedocs.io/en/latest/usage.html#versions)
- [Inspect dataset schemas](https://pyplaces.readthedocs.io/en/latest/usage.html#schemas)
- [Find relevant category names for retrieving places data](https://pyplaces.readthedocs.io/en/latest/usage.html#categories)

Most, if not all, of the functions follow the same type of workflow.

## Documentation

The documentation is available [here](https://pyplaces.readthedocs.io/en/latest/) in case you run into any issues. 

## License

pyplaces is open source and licensed under the MIT license. 

## pyplaces Usage

This package uses a geocoder that uses OpenStreetMaps's geocoding service Nominatim. Please abide by their usage policy [here](https://operations.osmfoundation.org/policies/nominatim).

## Future Support

- more readable schema output

- reduce time in the pyarrow parquet reading pipeline

- speed up model transactions- current implementation is inefficient

- support more geoparquet datasets

- basic network analysis for transportation data
InstallerReady 0.8
A Tkinter GitHub project installer
Requires Python: >=3.8

# InstallerReady

A python 3 app that allows users to install programs/apps.

https://github.com/coltonsr77/Python3-windows-installer uses InstallerReady as a helper tool for installing apps or apps thats needed. (ONLY HAS 0.3 OR HIGHER)

## Installation
```bash
pip install InstallerReady
finesse-benchmark-database 0.1.13
Data generation factory for atomic probes in Finesse benchmark. Generates probes_atomic.jsonl from Wikimedia Wikipedia.
Requires Python: <4.0,>=3.10

---
license: apache-2.0
---

[Github](https://github.com/enzoescipy/finesse-benchmark)
[huggingface](https://huggingface.co/datasets/enzoescipy/finesse-benchmark-database)
[pypi](https://pypi.org/project/finesse-benchmark/)
[blog](https://www.winter-sci-dev.com/posts/embed-sequence-merger-vbert-ppe-article/)

# Finesse Benchmark Database

## Overview

`finesse-benchmark-database` is a data generation factory for atomic probes in the Finesse benchmark. It generates `probes_atomic.jsonl` files from Wikimedia Wikipedia datasets, leveraging Hugging Face's `datasets` library, tokenizers from `transformers`, and optional PyTorch support.

This tool is designed to create high-quality, language-specific probe datasets for benchmarking fine-grained understanding in NLP tasks.

## Installation

Install the package from PyPI:

```bash
pip install finesse-benchmark-database
```

Ensure you have Python 3.10+ installed.

## Usage

Here's a complete example of how to configure and generate a dataset:

```python
from finesse_benchmark_database.config import ProbeConfig
from finesse_benchmark_database.main import generate_dataset

# Define the configuration
my_config = ProbeConfig(
    languages=['en', 'ko'],  # Languages to generate probes for
    samples_per_language=10,  # Number of samples per language (reduce for testing)
    output_file='my_first_probes.jsonl',  # Output file path
    seed=123  # Random seed for reproducibility
)

# Generate the dataset
print(f"Generating '{my_config.output_file}'...")
generate_dataset(my_config)
print("Dataset generation completed!")
```

### Configuration Options

- `languages`: List of language codes (e.g., ['en', 'ko', 'fr']).
- `samples_per_language`: Number of probe samples to generate per language.
- `output_file`: Path to the output JSONL file.
- `seed`: Optional seed for deterministic results.

## Requirements

- `datasets`
- `transformers`
- `torch` (for tokenization)

## License

This project is licensed under the Apache-2.0 license.

## Contributing

Contributions are welcome! Please open issues or pull requests on the [GitHub repository](https://github.com/your-repo/finesse-benchmark-database).
elegantmotd 1.0.1
A visually appealing and informative Message of the Day (MOTD) generator for Linux systems.
Requires Python: >=3.12
Keywords: console, dashboard, information, motd, system

# ElegantMOTD

ElegantMOTD is a Python-based Message of the Day (MOTD) generator for displaying system information in a visually
appealing and informative manner. It works on Linux systems and provides details such as system load, disk usage, memory
usage, swap usage, temperature, network interfaces, CPU usage, and more.

## Features

- Rich, colorful text-based output.
- Displays various system information.
- Customizable visual theme.
- Easy to use and integrate into your system.

## Usage

To display the Message of the Day, run the following command:

```bash
elegantmotd
```

You can choose a visual theme using the `--theme` (or `-t`) option:

```bash
elegantmotd --theme emoji
elegantmotd -t nerdfont
```

### Available themes

- `none` (default): no icons, clean plain text (TTY-safe)
- `emoji`: colorful emojis for graphical environments
- `nerdfont`: icon-rich display using [Nerd Fonts](https://www.nerdfonts.com)

## Live Updates

If you want to enable live updates of the system information, you can use the `--watch`/`-w` option:

```bash
elegantmotd --watch
```

With the `--watch` option, the MOTD will be continuously updated with the latest system information.

## Output

![Output](resources/output.png)

## Customization

You can customize the output by modifying the `motd.py` file and adding or removing system information modules as per
your preference. The available modules are:

- Load
- Disk
- Memory
- Temperature
- Process
- LoggedInUsers
- Network
- CPU

To add or remove a module, simply add or remove the corresponding import statement and the respective class instance
from the `sysinfos` list in the `display()` function.

## Contributing

Pull requests are welcome. For major changes, please open an issue first to discuss what you would like to change.

Please make sure to update tests as appropriate.