semvec/pypi-packages huggingface dataset:
ccao 1.3.1
Convenience Functions and Datasets for the Cook County Assessor's Office
Requires Python: >=3.9

# CCAO Python package

This is a Python version of the [`ccao` R
package](https://ccao-data.github.io/ccao/), providing utilities for
managing, distributing, and version controlling *CCAO-specific* functions
used throughout CCAO applications, models, and diagnostics. For generalized
versions of assessment-related functions, see
[assesspy](https://github.com/ccao-data/assesspy).

## Installation

Install the latest release of `ccao` from PyPI:

```bash
pip install ccao
```

## Usage

See [the documentation](https://ccao-data.github.io/ccao/python/)
for detailed API reference.

## Development

See [`DEVELOPMENT.md`](https://github.com/ccao-data/ccao/blob/master/python/DEVELOPMENT.md)
for instructions on setting up a development environment.
PyAstroSALT 0.1.0
API access for the Southern African Large elescope (SALT).
Requires Python: >=3.11

# pyastrosalt

## Installation

```console
pip install pyastrosalt
```

## Development and deployment

[uv](https://docs.astral.sh/uv/) is used as the package manager for this project. There are several ways to install uv; see the official [installation instructions]((https://docs.astral.sh/uv/getting-started/installation/).

### Managing dependencies

 Use uv's `add` command for adding dependencies. For example:

```bash
uv add numpy
```

To add an optional dependency, use the `--optional` option. For example, if you want to add `pyjwt` to the optional group `secure`:

```bash
uv add --optional secure pyjwt
```

Optional groups are listed in the `project.optional-dependencies` section of `pyproject.toml`.

In case the dependency is required for development purposes only, you should use the `--dev` option. For example, the following will add pytest to the development only group:

```bash
uv add --dev pytest
```

Development only dependency groups are listed in the `dependency-groups` section of `pyproject.toml`. They `re not included in the published package.

### Documentation

The documentation is generated using [Materials for MkDocs](https://squidfunk.github.io/mkdocs-material/) and [mkdocstrings](https://mkdocstrings.github.io), and all its files are located in the `/docs` folder. You can view
the generated files by running

```bash
mkdocs serve
```

There also is a pdm script for building the documentation files.

Script | Description
--- | ---
`docs` | Build the documentation

However, contrary to `mkdocs serve`, this command does not let you preview the documentation as you write. It is mostly intended for testing purposes.

### Deployment

There is a GitHub workflow (`publish.xml`) for deploying the package to a package repository (such as PyPI). This workflow assumes that the GitHub repository is a trusted publisher. Refer to the PyPI documentation on how to [create a PyPI project with a trusted publisher](https://docs.pypi.org/trusted-publishers/creating-a-project-through-oidc/).

in addition, the workflow generates the documentation files and publishes them as a GitHub page (at [https://saltastroops.github.io/PyAstroSALT](https://saltastroops.gitub.io/PyAstroSALT)).

To see the deployed documentation, you might have to tweak some settings. Click on Settings in the top menu and then on Page in the sidebar menu. Choose to deploy from a branch, select gh-pages as the branch and / (root) as the folder, and click on the Save button.

![Settings for the GitHub pages](pages_settings.png)

The workflow is triggered whenever a release is created for the GitHub repository. The tag for the release must be the package's version number preceded by a "v". For example, if the package version is `"1.4.2"`, the tag must be `"v1.4.2"`. The tag must be for the current commit in the main branch.
skilift 0.1.5
Development facility for the skipole WSGI Application generator
Requires Python: >=3.8
Keywords: wsgi, application, web, framework

# README #

Project closed and archived

skilift is the development package for the skipole WSGI application framework.

Typically a developer's PC would have both the skilift and the skipole Python packages installed. Skilift can be used to generate a WSGI based web site, it includes a development web server and provides a web admin interface, which together with your own code and the skipole functions, enables the developer to create a wsgi application.

Once created, your application and its support files can be moved to your deployment server, which also needs a WSGI compatible web server, and the skipole package.

The deployment server does not need the skilift application.

Skipole and skilift requires python 3.6 or later, and can be installed with:

python3 -m pip install skipole

python3 -m pip install skilift

### Starting a new project ###

To create a new project you would normally run:

python3 -m skilift myproj /path/to/projectfiles

You should replace 'myproj' with your preferred name for a new project. A projectfiles directory will be created with your new project 'myproj' within it.

You would then run:

python3 /path/to/projectfiles/myproj.py

then connect with a browser to localhost:8000 to view the project, and call localhost:8000/skiadmin to open an administrative site to add and edit folders and pages.

### Developing a project ###

The file myproj.py contains code which generates the wsgi application, and functions which you will develop further yourself.

The pages served at /skiadmin provide the web based admin facility allowing you to create template and responder pages. Typically you set up 'responders' to accept an incoming call which in turn calls your own functions defined in myproj.py. Your code sets data into a Python object, which is set into a template page and returned to the caller.

Your Python functions in myproj.py are described in greater detail within the admin pages.

### Special features ###

The widget field values which you create are normally set into the returned template page, but they can also be set into a JSON file, which updates the widgets already displayed on the client browser. This enables facilities such as SVG meters and graphs to be dynamcally updated.

The widgets created have a look and feel set by CSS classes, you have the facility to set your own classes on the widgets to change their appearence.

### Final output ###

When you have fully developed your application, and wish to deploy it, you would remove the lines in myproj.py which import skilift and which run the admin functions and the development_server. You will be left with your final WSGI 'application' - which can be served by any WSGI compatable web server.

### Upgrading ###

To upgrade to the latest version:

python3 -m pip install --upgrade skipole

python3 -m pip install --upgrade skilift

### Further information ###

The web admin pages have extensive documentation and help features, and for further information go to:

https://bernie-skipole.github.io/skipole
currybo 0.1.0
Bayesian Optimization for general parameters
Requires Python: >=3.9

![CurryBO-logo](https://raw.githubusercontent.com/digital-chemistry-laboratory/currybo/refs/heads/main/CurryBO-logo.svg)
[![License: MIT](https://img.shields.io/badge/License-MIT-red.svg)](./LICENSE)
[![Python Version](https://img.shields.io/badge/Python-3.9%2B-blue?logo=python&logoColor=white)](https://www.python.org/)

[![arXiv](https://img.shields.io/badge/arXiv-2502.18966-b31b1b.svg)](https://arxiv.org/abs/2502.18966)



# CurryBO: Bayesian optimization over curried function spaces

`CurryBO` is a pure python package that allows to conduct Bayesian Optimization in the search for general (i.e. transferable) parameters that *work well* across multiple related tasks.

## Installation

To install the package, simply:
```
pip install currybo
```

## Usage

If you are interested in using CurryBO to predict your experiments based on your own measurements, you can simply call
```
currybo \
--measurements [your-data-file.csv] --options [your-options-file.csv] \
--substrates "name=[Your-substrate-class-name],type=smiles" \
--conditions "name=[Your-condition-class-name],type=smiles" \
--targets "name=[Your-target-name],type=scalar" \
--objectives "name=[Your-target-name],abs_threshold=[Your-target-threshold],maximize=True" \
```

If you do not want to code, please visit the (CurryBO Website)[currybo.ethz.ch], where we built a web-based application so that everyone can optimize for general reaction conditions.

If you are interested in using CurryBO to predict your next experiments, please refer to the (currybo-benchmarks repository)[https://github.com/digital-chemistry-laboratory/currybo-benchmarks.git], which contains datasets to reproduce the experiments in this work.

## Citation

If you use CurryBO in your research, please cite the corresponding paper:

```
@misc{schmid_one_2025,
	title = {One {Set} to {Rule} {Them} {All}: {How} to {Obtain} {General} {Chemical} {Conditions} via {Bayesian} {Optimization} over {Curried} {Functions}},
	url = {http://arxiv.org/abs/2502.18966},
	doi = {10.48550/arXiv.2502.18966},
	publisher = {arXiv},
	author = {Schmid, Stefan P. and Rajaonson, Ella Miray and Ser, Cher Tian and Haddadnia, Mohammad and Leong, Shi Xuan and Aspuru-Guzik, Alán and Kristiadi, Agustinus and Jorner, Kjell and Strieth-Kalthoff, Felix},
	month = feb,
	year = {2025},
	note = {arXiv:2502.18966 [cs]},
}
```