semvec/pypi-packages huggingface dataset:
temp-gmail 1.0.1
temp gmail api.
Requires Python: >=3.6

# temp-gmail-api

## Features

- **Create Temporary Emails:** Generate disposable emails quickly.
- **Fetch Messages:** Retrieve emails for the created email account.
- **Search by Keyword:** Efficiently search through the inbox to find relevant messages.
- **Session Management:** Handles browser-like sessions and cookies automatically.

## Installation

To use this module, ensure you have Python installed on your machine along with the `curl_cffi` package. You can install the required package using pip:

```bash
pip install curl-cffi temp-gmail
```

## Usage

Here's a basic example of how to use the GMail class from the module:

```py
from temp_gmail import GMail
# Creating an instance of the GMail class

gmail_instance = GMail()

# Creating a temporary email

email_address = gmail_instance.create_email()
print("Generated Email:", email_address)

# Loading the email list for the new email

emails = gmail_instance.load_list()
print("Emails:", emails)

# Example: Check for new items with a specific keyword

message_info = gmail_instance.check_new_item("welcome")
print("Message Details:", message_info)
```

## Methods

Here is a brief overview of some of the methods included in the GMail class:

```diff
- create_email()
> No parameters required.
> Returns the generated email address.
- load_list()
> No parameters required.
> Fetches all messages for the current email account.
- load_item(message_id)
> message_id: ID of the message to retrieve.
> Returns the contents of the specified message.
- check_new_item(keyword)
> keyword: The keyword to search for in messages.
> Searches all messages for the keyword and returns the first message ID with a match.
```

## Dependencies

curl_cffi: A Python package that provides a way to interact with curl via CFFI.
tensorflow-records 0.1.14
Simple standard + tools for I/O of TFRecords
Requires Python: >=3.10

# TFRecords

> Simple standard + tools for I/O of TFRecords

```
pip install tensorflow-records
```

## I/O

```python
import tensorflow as tf
import tf.records as tfr

image = tf.ones([1024, 768, 3], dtype=tf.uint8)
label = tf.constant('cat')

spec = tfr.spec(
  image=tfr.Tensor([1024, 768, 3], dtype='int'),
  label='string'
)

serialized = tfr.serialize(spec, image=x, label=y)
# b'\n+\n\x10\n\x05label\x12\x07\n\x05\n\x03cat\n\x17\n\x05image\x1...'

tfr.parse(spec).sample(tf.constant(serialized))
# { 'image': <tf.Tensor: shape=(1024, 768, 3) ...>, 'label': <tf.Tensor: shape=() ...> }


# or you can parse multiple at once
tfr.parse(spec).batch(tf.constant([serialized, serialized]))
# { 'image': <tf.Tensor: shape=(2, 1024, 768, 3) ...>, 'label': <tf.Tensor: shape=(2,) ...> }
```
supirfactor-dynamical 1.1.0
Dynamical Model Extension of the Supirfactor Model

# supirfactor-dynamical

[![PyPI version](https://badge.fury.io/py/supirfactor-dynamical.svg)](https://badge.fury.io/py/supirfactor-dynamical)
[![CI](https://github.com/GreshamLab/supirfactor-dynamical/actions/workflows/python-package.yml/badge.svg)](https://github.com/GreshamLab/supirfactor-dynamical/actions/workflows/python-package.yml/)
[![codecov](https://codecov.io/gh/GreshamLab/supirfactor-dynamical/branch/main/graph/badge.svg)](https://codecov.io/gh/GreshamLab/supirfactor-dynamical)

This is a PyTorch model package for creating dynamical, biophysical models of
transcriptional output and regulation.

### Installation

Install this package using the standard python package manager `python -m pip install supirfactor_dynamical`.
It depends on [PyTorch](https://pytorch.org/get-started/locally/) and the standard python scientific computing
packages (e.g. scipy, numpy, pandas).

### Usage

```
from supirfactor_dynamical import (
    SupirFactorBiophysical
)

# Construct model object
model = SupirFactorBiophysical(
    prior_network,                  # Prior knowledge connectivity network [Genes x TFs]
    output_activation='softplus'    # Use softplus activation for transcriptional model output
)

# Set prediction parameter
model.set_time_parameters(
    n_additional_predictions=10     # Make forward predictions in time during training
)

# Train model
model.train_model(
    training_dataloader,            # Training data in a torch DataLoader
    500                             # Epochs
)

# Save model
model.save("supirfactor_dynamical.h5")
```

Examples containing data loading, hyperparameter searching, and result testing are located in `./scripts/`
nr-objstore-util 0.11.0
Utility to bundle commonly used object store operations into an easy to use module
Requires Python: >=3.8

[![Lifecycle:Maturing](https://img.shields.io/badge/Lifecycle-Maturing-007EC6)](<Redirect-URL>)

# Object Storage / S3 Utility Methods

<img src="https://lh3.googleusercontent.com/pw/AM-JKLV5unOdDuG_o7QwVYaiUCaFePQtcVWxPMJekkMNgQzVxKfkir0Akv9adldYQQTLVPW1W0O5Aov_Ep-v6HFcA6EwL3olmrkQW9Tm5k96K9Iv8uZAnrzc68vWIIs8gRt_wahaTmEv-XF1W9pxAygsesPHzw=w1292-h792-no?authuser=0" width="600">

Glueing together some object storage functionality into a
easy to use python library.

Intent is to bundle up commonly used functions into a single
library that can be imported into other projects.

# Installing

`pip install nr_objstore_util`

# Creating an NRObjStoreUtil Object by passing credentials

```python
import NRUtil.NRObjStoreUtil as NRObjStoreUtil
objstor = NRObjStoreUtil.ObjectStoreUtil(
    "name of object store host",
    "object store user / access",
    "object store secret",
    "object store bucket"
)
```

# Creating an NRObjStoreUtil Object using env vars

First populate the following environment variables:
* OBJ_STORE_BUCKET
* OBJ_STORE_SECRET
* OBJ_STORE_USER
* OBJ_STORE_HOST

```bash
export OBJ_STORE_BUCKET=bucket_name
export OBJ_STORE_SECRET=sdf3jkllvjiojl;a4sf892ikfjovj
export OBJ_STORE_USER=ostoreuser
export OBJ_STORE_HOST=nrs.objectstore.gov.bc.ca
```


Then create the NRObjStoreUtil object without args:
```python
import NRUtil.NRObjStoreUtil as NRObjStoreUtil
objstor = NRObjStoreUtil.ObjectStoreUtil()
```

# Examples

... see the examples folder for examples
simplests 2.3.0
Unsupervised models for Semantic Textual Similarity
Requires Python: >=3.6

[![License](https://img.shields.io/badge/License-Apache%202.0-blue.svg)](https://opensource.org/licenses/Apache-2.0) [![Downloads](https://pepy.tech/badge/simplests)](https://pepy.tech/project/simplests)

#  Simple Sentence Similarity
We provide a collection of simple unsupervised semantic textual similarity methods to calculate semantic similarity between two sentences.

### References
If you find this code useful in your research, please consider citing:

```
@inproceedings{ranasinghe-etal-2019-enhancing,
    title = "Enhancing Unsupervised Sentence Similarity Methods with Deep Contextualised Word Representations",
    author = "Ranasinghe, Tharindu  and
      Orasan, Constantin  and
      Mitkov, Ruslan",
    booktitle = "Proceedings of the International Conference on Recent Advances in Natural Language Processing (RANLP 2019)",
    month = sep,
    year = "2019",
    address = "Varna, Bulgaria",
    publisher = "INCOMA Ltd.",
    url = "https://www.aclweb.org/anthology/R19-1115",
    doi = "10.26615/978-954-452-056-4_115",
    pages = "994--1003",
    abstract = "Calculating Semantic Textual Similarity (STS) plays a significant role in many applications such as question answering, document summarisation, information retrieval and information extraction. All modern state of the art STS methods rely on word embeddings one way or another. The recently introduced contextualised word embeddings have proved more effective than standard word embeddings in many natural language processing tasks. This paper evaluates the impact of several contextualised word embeddings on unsupervised STS methods and compares it with the existing supervised/unsupervised STS methods for different datasets in different languages and different domains",
}
}
```