semvec/pypi-packages huggingface dataset:
maskedtensor 0.10.0
MaskedTensors for PyTorch

# maskedtensor

MaskedTensor is a library that is part of the [PyTorch](https://pytorch.org/) project and is an extension of `torch.Tensor` by providing the ability to mask out the value for any given element. Elements with masked out values are ignored during computation and give the user access to advanced semantics such as masked reductions, safe softmax, masked matrix multiplication, filtering NaNs, and masking out certain gradient values.

## Installation

### Binaries

To install MaskedTensor via pip, use the following command:
```
pip install maskedtensor
```

Note that MaskedTensor requires PyTorch >= 1.11, which you can get on the [the main website](https://pytorch.org/get-started/locally/)

### From Source

To install from source, you will need Python 3.7 or later, and we highly recommend that you use an Anaconda environment. Then run:

```
python setup.py develop
```

## Documentation

Please find documentation on the [MaskedTensor Website](https://pytorch.org/maskedtensor/main/index.html).

### Building documentation

Please follow the instructions in the [docs README](https://github.com/pytorch/maskedtensor/tree/main/docs).

### Notebooks

For an introduction and instructions on how to use MaskedTensors and what they are useful for, there are a nubmer of  tutorials on the [MaskedTensor website](https://pytorch.org/maskedtensor/main/index.html).

## License

maskedtensor is licensed under BSD 3-Clause
Googlexcel-noPassword 1.11
Fetch all sheets of data from Google Spreadsheet Excel without auth/ password.
Requires Python: >=3.7

<h1>Googlexcel_noPassword</h1>   
_____________________________________________  

The First package built to easily obtain the data within an entire shared Google Spreadsheet without passing Google username/ password, credentials.json or OTP authentication.

_____________________________________________

<h2>Instructions.</h2>  

To install the package, perform:  

```python
pip install Googlexcel-noPassword
```
 
How to use the methods:  

<h3>1. To obtain the list of sheetnames:  </h3>

```python
#Importing Library.
import Googlexcel-noPassword as ggx

#url_GoogleSheets = The shared url of Google Spreadsheet document. (Ensure that the privilege is set to 'Anyone with the link'.)
list_ofSheetnames = ggx.fetch_sheetnameslist(url_GoogleSheets)
```

<h3>2. To obtain the dictionary with 'Key' = Sheetname and 'Value' = DataFrame:  </h3>

```python
#Returns a dictionary with all the sheetnames and their respective data as dataframe.
dict_Dataframes = ggx.data_fromAllSheets(url_GoogleSheets)
```

<h3>3. To obtain a single dataframe from one sheet.</h3>

```python
#Returns a dataframe for the data in one sheet.
df_sheetname = ggx.data_OneSheet(url_GoogleSheets, sheet_name)
``` 
_____________________________________________

<h3>Have fun with what is possibly the first library to bypass the credentials.json and the username/ password restrictions to fetch the entire Google Spreadsheet excel document.</h3>
jla-tailer 0.1.18
Tool to find 3' tailing of non-coding RNAs
Requires Python: >=3.6
Keywords: Sequencing,ncRNAs,Bioinformatics

# Tailer: A tool for 3' end analysis of non-polyadenylated RNAs from 3' sequencing data

## Requirements
- ``Python >= 3.6``
- ``pysam``
- ``Bio``
- ``gffuitls``
- ``requests``
- ``tqdm``

## Installation

```bash
pip install jla-tailer
```

## Usage

Global alignment with a GTF annotation and SAM/BAM formatted files
```bash
Tailer -a [GTF Annotation] [SAM or BAM Files]
```

Required Arguments

* ``-a, --annotation``
    - GTF formatted database to be used to infer 3' ends. Ensembl GTFs have worked well for this pipeline
* ``[SAM or BAM Files]``
    - Space separated list of sam/bam formatted file locations to perform 3' end tail analysis

Local alignment with with FASTA/Q and specific Ensembl IDs of interest or reference fasta
```bash
Tailer -e [comma separated list of EnsIDs no spaces] [FASTA/Q files]
Tailer -f fasta_reference_file.fasta [FASTA/Q files]
```

Required Arguments

* ``-e, --ensids``
    - Comma separated list of ensembl IDs. Either -e or -f inputs are required.
* ``-f, --fasta``
    - FASTA formatted file to align reads against. Either -f or -e inputs are required
* ``[Trimmed FASTQ files]``
    - Space separated FASTQ file locations for analysis.


Optional arguments

* ``-t, --threshold [int, default=100]``
    - Any alignment identified further than this distance in nucleotides from the mature end will be considered spurious and discarded
* ``-x, --trim [int, default=0]``
    - Helper for local mode only, can remove X nucleotides from adapter on the 3' end
* ``-read, --read [int, default=1]``
    - Paired end only. 1 or 2 to signify which end contains the 3' end information.
* ``-r, --rev_comp``
    - If set, will reverse complement the reads. Necessary for some library prep methods
* ``-f, --fasta``
    - Use a fasta file as a reference instead of building one from ensembl IDs (Local Only)
* ``-s, --sequence``
    - Output sequence in the tail file. Useful for debugging.


miRNA tailing (in development)
```bash
Tailer --miRNA [sam files]
```

Determines tails using an alignment file (SAM/BAM) that was aligned to a fasta genome of mature miRNAs

Optional arguments

* ``--rpad [int, default=0]``
    - Number of downstream nucleotides added to distinguish between post-transcriptional and genome-encoded tails
slack-types 0.0.2
Slack API Types in Python
Requires Python: >=3.7

# Slack API types

See:
- https://pypi.org/project/slack-types

This npm package is a collection of Python and TypeScript type definition of Slack APIs.

Currently, the package support the following APIs.

* API Methods (web-api)
* Events API (events-api)
* Real Time Messaging API (rtm-api)
* Incoming payloads from Slack Platform (app-backend)
  * Dialogs (dialog_submission, cancellation, suggestion)
  * Interactive Messages (interactive_message, block_action)
  * Message Actions (message_action)
  * Slash Commands

## How to use

For Python:
```python
from typing import Callable

# Requirement: install aiohttp
from slack_bolt.async_app import AsyncApp
from slack_sdk.web.async_client import AsyncWebClient
from slack_types.events_api.app_mention_payload import Event as AppMentionEvent

app = AsyncApp()

@app.event("app_mention")
async def handle_mentions(event: dict[str, str], client: AsyncWebClient, say: Callable):  # async function
    slack_mention = AppMentionEvent.from_dict(event)
    api_response = await client.reactions_add(
        channel=slack_mention.channel,
        timestamp=slack_mention.ts,
        name="eyes",
    )
    await say("What's up?")

if __name__ == "__main__":
    app.start(3000)
```

For TypeScript:
```typescript
import * as express from 'express';
import { Express, Request, Response } from 'express';

import * as Slack from '@slack/web-api';
import * as WebApi from 'seratch-slack-types/web-api';
import * as EventsApi from 'seratch-slack-types/events-api';

export const slackApi = new Slack.WebClient(process.env.SLACK_API_TOKEN);

export const app: Express = express();

app.post('/events', function (req: Request, res: Response) {
  const body = JSON.parse(req.body); // still "any" here

  if (body.type === 'url_verification') {
    // url verification
    res.status(200).send(body.event.challenge);

  } else if (body.type === 'event_callback' && body.event.type === 'message') { // still "any" here
    const payload = body as EventsApi.MessagePayload;
    // `payload.event.text` here is typesafe
    slackApi.api.test({ text: payload.event.text })
      .then((response: WebApi.ApiTestResponse) => { // `response` is typesafe
        if (response.ok) {
         // do something here
        } else {
         // do something here
        }
      }).catch(reason => {
        // do something here
      });
  } else {
    // do something here
  }
  res.status(200).json({ message: 'thanks!' });
});
```

## How are the types generated

These types are generated from jSlack library's type definitions in Java + actual JSON responses fetched by running jSlack's unit tests. If you're interested in the details, take a look at [jSlack](https://github.com/seratch/jslack).

The coverage may not be 100% yet. A portion of the properties may be incorrect. If you find missing properties or something wrong, let us know here: https://github.com/seratch/seratch-slack-types/issues

To re-generate:

```bash
$ npm install
$ npm run build
```

## License

The MIT License