semvec/pypi-packages huggingface dataset:
fyodorov-utils 0.4.52
Utilities for the Fyodorov AI suite
Requires Python: >=3.8

# Fyodorov Utils

<p>
<img alt="GitHub Contributors" src="https://img.shields.io/github/contributors/fyodorovai/fyodorov-utils" />
<img alt="GitHub Last Commit" src="https://img.shields.io/github/last-commit/fyodorovai/fyodorov-utils" />
<img alt="" src="https://img.shields.io/github/repo-size/fyodorovai/fyodorov-utils" />
<img alt="GitHub Issues" src="https://img.shields.io/github/issues/fyodorovai/fyodorov-utils" />
<img alt="GitHub Pull Requests" src="https://img.shields.io/github/issues-pr/fyodorovai/fyodorov-utils" />
</p>

`fyodorov_-_utils` is a Python library that provides a collection of utility functions and classes used across multiple 
services within the Fyodorov project. The Fyodorov project is a suite of complementary services for working with 
LLM-based agents.

The library defines standard practices and includes tooling around logging, error handling, and authentication, 
as well as configuration management.

### Error handling
There is a decorator which will handle errors for FastAPI endpoints. It will also log those errors in a consistent 
fashion without any input required. It can be used like this:
```Python
from fyodorov_utils.decorators.logging import error_handler

@app.post
@error_handler
def endpoint():
    return 
```

### Authentication
You can import the authentication helper like so:
```Python
from fyodorov_utils.auth.auth import authenticate

@app.post('/endpoint')
@error_handler
def create_provider(provider: ProviderModel, user = Depends(authenticate)):
    return
```

This will require calls to that endpoint to be authenticated by the user's access token (which is a JWT). It also makes 
the user object available within the function for additional authentication or authorization logic.

### Shared User Endpoints
There are certain endpoints around user actions that are shared functionality across all services. These include 
signing up, logging in, and creating API keys (which can be used for **tools** or third-party services). These 
endpoints are defined in the library and can be used like this:

```Python
# User endpoints
from fyodorov_utils.auth.endpoints import users_app
app.mount('/users', users_app)
```

## Installation

You can install `fyodorov_utils` using pip: 
```shell
pip install fyodorov-utils==0.2.11
```
pccg 0.0.3
Add your description here
Requires Python: >=3.12

# Potential Contrasting Coarse Graining

## Introduction

[Potential contrasting](https://pubs.acs.org/doi/10.1021/acs.jctc.2c00616) is an efficient method for learning a potential energy function that can reproduce an ensemble of molecular conformations. It can be easily applied to can learn coarse-grained force fields based on all-atom simulations. It generalizes the [noise contrastive estimation method](https://proceedings.mlr.press/v9/gutmann10a) to use complex unnormalized noise distributions constructed using molecular dynamics techniques such as [umbrella sampling](https://en.wikipedia.org/wiki/Umbrella_sampling).

## Getting Help

Need help? Checkout the [documentation](https://pccg.readthedocs.io).
Mathics3-Module-PyICU 9.0.0
Mathics3 Hello, World! module
Requires Python: >=3.10
Keywords: Mathematica, Wolfram, Interpreter, Shell, Math, CAS

Mathics3 Module for ICU — International Components for Unicode

Functions that provide information from the `Python ICU library <https://pypi.org/project/pyicu/>`_.

Example Session
---------------

::

   $ mathicsscript
   In[1]:= LoadModule["pymathics.icu"]
   Out[1]= pymathics.icu

   In[2]= Alphabet["Croatian"]
   Out[2]= {a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, r, s, t, u, v, z, ć, č, đ, š, ž, dž, lj, nj}

   In[3]:= $Language
   Out[3]= "English"

   In[4]:= Alphabet[]
   Out[4]= {a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z}

   In[5]:= $Language="German"
   Out[5]= "German"

   In[6]:= Alphabet[]
   Out[6]= {a, ä, b, c, d, e, f, g, h, i, j, k, l, m, n, o, ö, p, q, r, s, ß, t, u, ü, v, w, x, y, z}

   In[7]:= AlphabeticOrder["Papá", "Papagayo", "Spanish"]
   Out[7]= 1

   In[8]:= AlphabeticOrder["Papá", "Papa", "Spanish"]
   Out[8]= -1

   In[8]:= AlphabeticOrder["Papá", ""Papá", "Spanish"]
   Out[8]= 0
Sentinel-2-band-downloader 0.3.4
Utility for searching and downloading satellite images of Sentinel 2
Requires Python: >=3.10

# Sentinel-2 Band Downloader

## Overview

Sentinel-2 Band Downloader is a simple Python package that allows users to download individual bands from Sentinel-2 satellite data.

This package simplifies the process of connecting to the Sentinel API, retrieving product information, creating output folders, obtaining band links, and downloading bands.

## Installation

### Using pip

You can install the package using `pip`:

```bash
pip install Sentinel_2_band_downloader
```

### Clone repository
git clone https://github.com/beatriznattrodtdavila/Sentinel_2_band_downloader.git
cd Sentinel_2_band_downloader
pip install -e .

## Example

```python
# Import the Sentinel2_Band_Downloader class
from scr.main.sentinel_2_band_downloader import Sentinel2_Band_Downloader

# Initialize the downloader with log and output paths (replace "/path/to/output")
downloader = Sentinel2_Band_Downloader(output_base_path="/path/to/output")

# Connect to the Copernicus API (replace 'your_username' and 'your_password')
access_token, refresh_token, dt_access_token = sentinel_downloader.connect_to_api(username, password)

# Construct a query for Sentinel-2 products
""" The parameters must be like:
        footprint: str
            The spatial geometry (POLYGON) of the area of interest.
        start_date: str
            The start date for the time range of interest in the format 'YYYY-MM-DD'.
        end_date: str
            The end date for the time range of interest in the format 'YYYY-MM-DD'.
        cloud_cover_percentage: str
            The maximum allowable cloud cover percentage.
        type: str or list
            Type of MSI to download
        platform_name: str, optional
            The name of the Sentinel platform (default: 'SENTINEL-2').
"""
query_params = downloader.construct_query(footprint="your_footprint", start_date="start_date", 
                                          end_date="end_date", cloud_cover_percentage="cloud_cover", 
                                          type="your_type", platform_name="your_platform_name")


# Write the bands to download
bands_dict = {"L1C":["B01", "B02", "B03", "B04", "B05", "B06", "B07", "B08", "B8A", "B09", "B10", "B11", "B12", "TCI"],
                  "L2A":{"10m": ["AOT", "B02", "B03", "B04", "B08", "TCI", "WVP"],
                  "20m": ["AOT","B01", "B02", "B03", "B04", "B05","B06", "B07", "B8A", "B11", "B12", "SCL", "TCI", "WVP"],
                  "60m": ["AOT","B01", "B02", "B03", "B04", "B05","B06", "B07", "B8A", "B09","B11", "B12", "SCL", "TCI", "WVP"]}}

# Download Sentinel2 Bands
downloader.download_sentinel2_bands(access_token, filter_list, bands_dict, dt_access_token, refresh_token, None)
```
frame-alignment-checks 0.0.73
Library for determining whether a RNA splicing predictor is using frame alignment information
Requires Python: >=3.9


# Frame alignment checks

Set of tools for checking whether splicing prediction models are using frame alignment information. Does so on a set of
"long canonical internal coding exons" (see below for definition).

## Data sourcing

### Long canonical internal coding exons

These are computed using the following conditions.

 - appear in the SAM validation set (first half of the SpliceAI test set) of canonical exons in certain chromosomes
 - have exactly one ensembl annotation whose transcript is the same as the canonical transcript
 - start and end in a coding region
 - length at least 100nt

this set is built in to the package and does not need to be provided by the user.

The sources used to construct this are the SpliceAI dataset [1]
via the SAM repository's implementation (which is itself based on the SpliceAI implementation) [2]
and the Ensembl database [3].

### Relevant validation genes

These are sourced, like the long canonical internal coding exons, from the SAM validation set. Only genes relevant to
the long canonical internal coding exons are pulled.

### Minigenes

The minigenes are sourced from the hg19 canonical transcript, defined in the same way as SpliceAI's canonical transcript.

### Saturation Mutagenesis test benchmark

This is sourced from [https://genome.cshlp.org/content/suppl/2017/12/14/gr.219683.116.DC1/Supplemental_Table_S2.xlsx](this link) and is
cached in this package in case the link goes down.

### Phase handedness counts

This is a count of how many times each donor 9mer appears in each phase. This is sourced from the SpliceAI training set, via SAM.

### Non-stop donor windows

This is a collection of donors from the SpliceAI test set (again via SAM), specifically ones where swapping the donor 9mer
with an arbitrary sequence would not introduce a stop in the exon. Basically, we exclude conditions where the
flanking exon ends with a sequence that is a prefix of a stop codon, these are T, TA, and TG.

### Acceptor and donor LSSI models

These are models trained on the SpliceAI training set, via SAM. Copied directly from [https://github.com/kavigupta/sam/tree/main/spliceai/Canonical/splicepoint-models](here). We only use
these in tests, and they are not required for the package to run.

[1]: Jaganathan, Kishore, et al. "Predicting splicing from primary sequence with deep learning." Cell 176.3 (2019): 535-548.
[2]: https://github.com/kavigupta/sam
[3]: https://useast.ensembl.org/index.html