semvec/pypi-packages huggingface dataset:
torch-analyzer 1.4.2
A torch model analyzer
Requires Python: >=3.7

# Torch Analyzer

This tool can be used to analyze the model run time, GPU memory usage, input/output information of each layer, and FLOPs of each layer in PyTorch models.

The run time, GPU memory usage, and FLOPs are analyzed at the **cuda operator level**, which is more accurate than the existing module-based analysis. Even model with custom operators can be analyzed.

![example1](./imgs/v1.png)

## Installation
Install from pip:
```bash
pip install torch-analyzer
```

Install from source:
```bash
git clone https://github.com/IrisRainbowNeko/torch-analyzer.git
cd torch-analyzer
pip install -e .
```

## Usage
Example:
```python
import torch
import torchvision.models as models
from torchanalyzer import ModelTimeMemAnalyzer, TorchViser

model = models.resnet18().cuda()
inputs = torch.randn(1, 3, 224, 224).cuda()

analyzer = ModelTimeMemAnalyzer(model)
info = analyzer.analyze(inputs)
TorchViser().show(model, info)
```

### Analyze model
Analyze run time of each layer:
```python
from torchanalyzer import ModelTimeMemAnalyzer

analyzer = ModelTimeMemAnalyzer(model)
info = analyzer.analyze(inputs)
```

Analyze input/output information of each layer:
```python
from torchanalyzer import ModelIOAnalyzer

analyzer = ModelIOAnalyzer(model)
info = analyzer.analyze(inputs)
```

Analyze flops of each layer:
```python
from torchanalyzer import ModelFlopsAnalyzer

analyzer = ModelFlopsAnalyzer(model)
info = analyzer.analyze(inputs)
```

### Show Analyzed Information
Show with the style like `print(model)` in torch:
```python
from torchanalyzer import TorchViser
TorchViser().show(model, info)
```

Show with table style:
```python
from torchanalyzer import TableViser
TableViser().show(model, info)
```

Show with flow style:
```python
from torchanalyzer import FlowViser
FlowViser().show(model, info)
```

### Backward Analyze
Analyze run time and memory of each layer in backward:
```python
from torchanalyzer import ModelTimeMemAnalyzer

analyzer = ModelTimeMemAnalyzer(model)
info = analyzer.analyze(inputs, with_backward=True)
```
multiMotif 1.2.6
A Computational Tool for Variable Motif scanning and Sequence-based Relative Position Visualization of Search Results in Sequences.

# multiMotif
 A generalized tool for scanning and visualization of diverse and distant multiple motifs.

## Installation

To install multiMotif, you can use [pip](https://pip.pypa.io/en/stable/installation/)(we recommend using this method for installation.):

```
pip install multiMotif
```


Or clone the repository and then install it local:

```
git clone https://github.com/SainanLuo/multiMotif.git
cd multiMotif
pip install .
```


As a Windows user, you can choose to download [the installation package](https://github.com/SainanLuo/multiMotif/releases/download/v1.2.5/multiMotif.exe) and follow the prompts to install it.


## Dependencies

multiMotif requires the following packages:

`Biopython (>= 1.78)`

`Matplotlib (>= 3.3)`

`NumPy (>= 1.19)`

`Pandas (>= 1.1)`

`plotly (>=5.18.0)`

`kaleido(>=0.2.1)`

These dependencies will be installed automatically when you install multiMotif using pip.


## Usage

After installation, you can use the `multiMotif` command to run multiMotif. Here is the basic usage:

```
usage: multiMotif [-h]
                  {singleMotif,multiMotif,visualMotif,extract_sequences} ...

VariaMotif for motif scanning

positional arguments:
  {singleMotif,multiMotif,visualMotif,extract_sequences}
                        sub-command help
    singleMotif         Scanning for single motif
    multiMotif          Scanning more than two ordered motifs
    visualMotif         Visualization:display motif in sequence
    extract_sequences   Extract Sequences

optional arguments:
  -h, --help            show this help message and exit
```

multiMotif tool features modules for identifying single motifs(‘singleMotif’), multiple motifs(‘multiMotif’), a visualization module (‘visualMotif’) to enhance results interpretation, and a sequence extraction module (‘extract_sequences’) for obtaining promoters or open reading frames, or user-specified locations. 


We provide comprehensive user manuals in both Chinese and English. You can download the English version of the manual at [English Language User Manual Download Link](https://github.com/SainanLuo/multiMotif/releases/download/v1.2.5/multiMotif_Installation_UsageInstructions_EnglishLanguage.pdf). For the Chinese version, please visit this link:[Chinese Language User Manual Download Link](https://github.com/SainanLuo/multiMotif/releases/download/v1.2.5/multiMotif_Installation_UsageInstructions_ChineseLanguage.pdf).
ProgressGym 0.0.2
alpha
Requires Python: >=3.8

# ProgressAlign: Dataset & Experimental Framework for Progress-Aware Alignment

## Building the dataset

- Running `python ./build_dataset.py` will automatically download the relevant files and then compile them into the desired dataset. Specifically, it will...
  - Download and decompress raw data files from multiple sources, placing them in `./dataset/raw_downloads` 
  - Organize downloaded data into an unified format, and the resulting historical text dataset is saved as a series of files `./dataset/dataset_textseq/[century_num]/[year_num].json` 
  - Train a series of historical language models  `./dataset/dataset_modelseq/[century_num]` using the historical text dataset.



## Running the benchmark

- Running `python ./run_benchmark.py --challenge [challenge_name] --testtaker [path_to_tested_system]` will produce the benchmark results. Omitting `--challenge [challenge_name]` will default to testing all challenges.
scuamate 0.0.4
Some Cloud Utilities to Advance Monitoring of Animals and Their Ecosystems: utilities to help run, maintain, check, and back up the cloud infrastructure for next-generation wildlife monitoring projects (including SpaceCows and the National Koala Monitoring Program)
Requires Python: >=3.9
Keywords: wildlife biodiversity ecological monitoring citizen community science

# SCUAMATE
### '**S**ome **C**loud **U**tilities to **A**dvance **M**onitoring of **A**nimals and **T**heir **E**cosystems' (or, '**S**ome **C**loud **U**tilities for **A**nimals, **MATE**')

A Python package containing utilities to help run, maintain, check, and back
up the cloud infrastructure for next-generation wildlife monitoring projects
(originally developed at CSIRO for SpaceCows and the National Koala Monitoring Program)

##### Contents:
- **scuamate**: a variety of general-purpose classes and functions
- **scuamate.az**: functions for working with Azure services, including:
  - **scauamate.az.keyvault**: for pulling secrets from an Azure KeyVault
  - **scauamate.az.mssql**: for connecting to, pulling data from, pushing data to, and editing data in an MSSQL database
  - **scauamate.az.azfuncs**: for working with Azure functions 
- **scuamate.gc**: functions for working with Google Cloud services, including:
  - **scuamate.gc.firestore**: functions for running CRUD operations on a Firestore database
- **scuamate.gsattrack**: functions for authenticating with and getting data from the GSatTrack API
GavinReportPro 1.0.0
Report for unittest
Requires Python: >=3.6
Keywords: Gavin, GavinHaydy, ruffian, GavinReportPro

![](https://img.shields.io/badge/Version-1.0.0-green.svg)
![](https://img.shields.io/badge/License-MIT-orange.svg)
![](https://img.shields.io/badge/Python-3-green.svg)

# Introduction
```text
Modified based on unittestreport
Added automatic screenshot and picture display for assertion failure
Added the lark Robot api
```

# Install
```text
pip install TheRuffianReportPro
```

# Author
```text
name:TheRuffian
email:bugpz2779@gmail.com
email:theruffian@163.com
```

# Instructions for use
### Case

```python
import unittest
from selenium import webdriver
from GavinReportPro.common import failure_monitor


class Test_demo(unittest.TestCase):
    def setUp(self) -> None:
        self.driver = webdriver.Chrome()
        self.failureException = failure_monitor(self, 'images')
        self.driver.get("url")

    def test_example(self):
        self.driver.find_element(By, Element).send_keys(keyword)
        self.driver.find_element(By, Element).click()
        self.assertEqual(first, second)  # Take a screenshot if the first assertion fails 

```
### Run

```python
import unittest
from GavinReportPro.core.testRunner import TestRunner
from case.xxx import Test_demo

runner = TestRunner(unittest.TestLoader().loadTestsFromTestCase(Test_demo),
                    filename='report.html',
                    report_dir='./Report',
                    templates=3)
runner.run()
```
numpy-extension 0.0.1.2.1
This Python package extends the functionality of numpy by introducing additional methods for data manipulation, and a specialized format for reading and writing numpy arrays.
Requires Python: >=3.7

# Numpy Extension

This Python package extends the functionality of numpy by introducing additional methods for data manipulation, and a specialized format for reading and writing numpy arrays.

## Features

- **Read `NDArray` in Need with Keys**: Using a key to load the required array without load all.
- **Array Mapping and Transformation Functions**: Functions to apply operations across arrays, adjust their ranges, and produce linearly spaced values with specific properties.

## Installation
```bash
pip install numpy_ext
```

## Usage

### Transformation Functions

- **apply_from_axis**: Apply a function to slices of an array along a specified axis.
- **map_range**: Transform elements in an array to a specified range.
- **map_ranges**: Transform elements in an array to multiple specified ranges based on conditions.
- **linspace_at**: Generate linearly spaced numbers for given indices.
- **linspace_cumprod_at**: Generate a cumulative product series for linearly spaced values at specific indices.

### Save and Load Utilities

- **savek**: Save multiple numpy arrays to a custom binary format `.npk`.
- **loadk**: Load arrays from a `.npk` file and read in need for easy access.
pyglicko2 0.0.1a2
Python implementation of the Glicko-2 system
Requires Python: >=3.8
Keywords: chess, rating-system

# PyGlicko2

![PyPI - Version](https://img.shields.io/pypi/v/pyglicko2)
![PyPI - License](https://img.shields.io/pypi/l/pyglicko2)

Python implementation of the Glicko-2 system

## Installing with pip

To install PyGlicko2 using pip, run the following command:
```
pip install pyglicko2
```

## Contributing

PyGlicko2 is in an early development stage, so we welcome help from you guys :)

### Building from source

To build PyGlicko2 from source, clone PyGlicko2's Github repository using `git`:
```
git clone https://github.com/cyan-ice/pyglicko2.git
```
Then, in the `pyglicko2` repository you just cloned, execute the following command:
```
pip install dist/pyglicko2-*-py3-none-any.whl
```
Where `*` is the latest version of PyGlicko2.

### Testing

To execute all tests, run
```
python test.py
```
In the current directory.

You should see something like this:
```
Test #1: Passed in 0.000s
Test #2: Passed in 0.000s
Passed 2/2
```

### Documentation

We don't have a real documentation for PyGlicko2 at the moment, please contact [@cyan-ice](https://github.com/cyan-ice) if you have any interest in contributing to our docs.