semvec/pypi-packages huggingface dataset:
bedmap 0.0.2
A Python package to automate the classification of glacially derived bedforms.
Requires Python: >=3.9

<p align="center">
  <img width="450" src="https://github.com/elliesch/rf_bedform_mapping/blob/main/figs/logo.png"/>
</p>

# `bedmap`: A Python package for the Automatic Detection of Glacially-derived Bedforms

The `bedmap` workflow automates the detection of glacially-derived bedforms for landforms identified from the Topographic Position Index (TPI) tool using machine learning. Users can pick one of three trained ensemble models (Random Forest, XGBoost, or the ensemble average of both) to detect bedforms from positive relief landforms, and choose to output detections as bedform probabilities or as binarized predictions. `bedmap` also includes a routine for running a scientifically-driven prefiltering routine on TPI data to prepare it for use with machine learning models.

`bedmap` can be used directly in Python, or as part of our ArcGIS pipeline, which incorporated with TPI, allows for the detection of bedforms directly from DEMs. Check out the notebooks available here or on CryoCloud for examples of how to apply `bedmap` to your data, or follow the quickstart guide below.

# Installation

`bedmap` can be installed using `pip`:

```bash
pip install bedmap
```

Note that the `bedmap` package requires Python 3.9 or later.

# Quickstart

Import the main interface:

```python
from bedmap import ClassifyBedforms
```

Automatically detect bedforms from a TPI output CSV:

```python
# Instantiate bedmap
landforms = ClassifyBedforms(
  input_csv='~/path/to/your/TPI/CSV',  # path to your input TPI csv
  model='ensemble_average',            # machine learning model choice
  threshold=0.45,                      # probability threshold
  probability=False                    # output as a binary prediction
)

# Define the predicted landforms
predicted_bedforms = landforms.predicted_bedforms
```

# References & Attribution
The code is under development and will be described in a paper and jupyter book.
If you make use of this code in your research, please cite:
```
LaTeX citations to go here.
```
pplx 0.1.3
Ein Hilfsmodul für die Perplexity API
Requires Python: >=3.6

# README

## Overview

The `PerplexityAPI` class is a Python wrapper for interacting with the Perplexity AI API. It allows users to send chat completion requests to the API and retrieve responses. This class handles the creation of payloads, sending requests, and parsing responses.

## Installation

To use the `PerplexityAPI` class, you need to have the `requests` library installed. You can install it using pip:

```
pip install requests
```

## Usage

### Initialization

To initialize the `PerplexityAPI` class, you need to provide your API key:

```python
from perplexity_api import PerplexityAPI

api_key = "your_api_key_here"
api = PerplexityAPI(api_key)
```

### Sending a Request

To send a request to the Perplexity AI API, use the `send_request` method. You need to specify the model and messages, and you can also provide additional keyword arguments:

```python
model = "your_model_name"
messages = [
    {"role": "system", "content": "You are a helpful assistant."},
    {"role": "user", "content": "Tell me a joke."}
]

response = api.send_request(model, messages)
```

### Retrieving the Response

To retrieve the response content from the API, use the `get_response` method. You can pass the JSON data returned by the `send_request` method, or it will use the last response stored in the instance:

```python
content = api.get_response(response)
print(content)
```

## Methods

### `__init__(self, api_key)`

Initializes the `PerplexityAPI` instance with the provided API key.

- `api_key`: Your API key for the Perplexity AI API.

### `create_payload(self, model, messages, **kwargs)`

Creates the payload for the API request.

- `model`: The model name to use for the request.
- `messages`: A list of message dictionaries.
- `**kwargs`: Additional keyword arguments to include in the payload.

### `send_request(self, model, messages, **kwargs)`

Sends a request to the Perplexity AI API and returns the JSON response.

- `model`: The model name to use for the request.
- `messages`: A list of message dictionaries.
- `**kwargs`: Additional keyword arguments to include in the payload.

### `get_response(self, json_data=None)`

Retrieves the response content from the JSON data. If no JSON data is provided, it uses the last response stored in the instance.

- `json_data`: The JSON data returned by the `send_request` method (optional).

## Example

```python
from perplexity_api import PerplexityAPI

api_key = "your_api_key_here"
api = PerplexityAPI(api_key)

model = "your_model_name"
messages = [
    {"role": "system", "content": "You are a helpful assistant."},
    {"role": "user", "content": "Tell me a joke."}
]

response = api.send_request(model, messages)
content = api.get_response(response)
print(content)
```

This example demonstrates how to initialize the `PerplexityAPI` class, send a request to the Perplexity AI API, and retrieve the response content.
eflux 0.1.0
Add your description here
Requires Python: >=3.8

# E-Flux (combining Expression Data with Fluxes)

[![Actions status](https://github.com/pnnl-predictive-phenomics/eflux/workflows/CI/badge.svg)](https://github.com/pnnl-predictive-phenomics/eflux/actions)
[![Rye](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/rye/main/artwork/badge.json)](https://rye-up.com)
[![License](https://img.shields.io/badge/License-BSD_2--Clause-orange.svg)](https://opensource.org/licenses/BSD-2-Clause)
[![Ruff](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ruff/main/assets/badge/v2.json)](https://github.com/astral-sh/ruff)

Package to run E-Flux on `cobra` models with provided transcriptomics expression data.


## Getting Started 🏃

To get started run the following:

```python
from eflux import eflux2

eflux2(cobra_model, transcriptomics)
```

## Installation 🪛

The most recent code and data can be installed directly from GitHub with:

```shell
pip install git+https://github.com/pnnl-predictive-phenomics/eflux.git
```

## License 📄

The code in this package is licensed under the BSD-2 License.


## Contributing 👋
To contribute to this package, please reference [CONTRIBUTING.md](CONTRIBUTING.md)
codec-sdk 0.2.9
Python Library for the Codec API
Requires Python: >=3.8

# Codec Python Library

The Codec Python library provides convenient access to the Codec API from applications written in Python 3.

## Documentation

See the [Codec docs](https://docs.codec.io).

## Installation

You don't need this source code unless you want to modify the package. If you just want to use the package, just run:

```python
pip install --upgrade codec-sdk
```

### Requirements
Python 3.8+


## Usage

The library needs to be configured with your team's API key which is available in the [Codec Dashboard](https://codec.io/dashboard). Instantiate the Codec client with it:

```python
from codec import Codec

codec = Codec("pk_xxx...")

# Get a collection
collection = codec.collections.get("col_xxx...")

# Search within videos in a collection
query = "trump wearing a red hat and talking about north korea"
results = codec.search(
    query=query,
    search_types=["visual", "speech"],
    collection=collection.uid,
    max_results=5
)
```

### Handling exceptions
Unsuccessful requests raise exceptions. The class of the exception will reflect the sort of error that occurred, and the error message will provide more context. See the [API reference](https://docs.codec.io) for a description of the error classes you should handle.


## Support
For support, reach out to [support@codec.io](mailto:support@codec.io).