semvec/pypi-packages huggingface dataset:
matrix-multiply-lib 1.0.0
A matrix multiplication library
Requires Python: >=3.7

# Matrix Multiply Library

A Python library for matrix multiplication supporting matrices of different dimensions.

## Installation

```bash
pip install matrix-multiply-lib
```
##Usage
```bash
from matrix_multiply import Matrix, matrix_multiply

# Create matrices
matrix_a = Matrix([[1, 2], [3, 4]])
matrix_b = Matrix([[5, 6], [7, 8]])

# Method 1: Using Matrix class
result = matrix_a * matrix_b
print(result)

# Method 2: Using convenience function
result = matrix_multiply([[1, 2], [3, 4]], [[5, 6], [7, 8]])
print(result)
mepo 2.4.0
A tool for managing (m)ultiple r(epo)s
Requires Python: >=3.9

# mepo [![Actions Status](https://github.com/pchakraborty/mepo/workflows/Unit%20testing%20of%20mepo/badge.svg)](https://github.com/pchakraborty/mepo/actions) [![DOI](https://zenodo.org/badge/215067850.svg)](https://zenodo.org/badge/latestdoi/215067850) [![Rye](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/rye/main/artwork/badge.json)](https://rye-up.com) [![Ask DeepWiki](https://deepwiki.com/badge.svg)](https://deepwiki.com/GEOS-ESM/mepo)

`mepo` is a tool, written in Python3, to manage (m)ultiple git r(epo)sitories, by attempting to create an illusion of a 'single repository' for multi-repository projects. Please see the [Wiki](../../wiki) for examples of `mepo` workflows.


## Installation

### Using pip

To install `mepo` using `pip`, run the following command:

```
pip install mepo
```

### Using uv

#### uv install

You can install `mepo` using the `uv` package manager. To do so, run the following command:

```
uv install mepo
```

#### uvx

If you'd like to run `mepo` without installing it, you can use `uvx` to run it directly:

```
uvx mepo
```

### Homebrew

Using Homebrew, you can install `mepo` by installing from the gmao-si-team tap:

```
brew install gmao-si-team/packages/mepo
```

This is equivalent to running:

```
brew tap gmao-si-team/packages
brew install mepo
```

### Spack

Mepo is also available via spack as a package. To install mepo using spack, run the following command:

```
spack install mepo
```

## Transitioning from `mepo` v1.x to v2.x

If you try to use mepo v2.x within a mepo v1.x repository, you will get an warning message:
```
Detected mepo1 style state
Run <mepo update-state> to permanently convert to mepo2 style
```

To update your repository to work with mepo v2.x, you can run the following command:
```
mepo update-state
```
and it will convert the repository from mepo v1 pickle-state to mepo v2 json-state.

## Commands

For more about the possible `mepo` commands, please see the [Mepo Commands](https://github.com/GEOS-ESM/mepo/wiki/Mepo-Commands) wiki page.

## Presentation

The SI Team has made a PowerPoint about `mepo` that can be found [here](https://github.com/GEOS-ESM/mepo/wiki/files/MEPO-2020Nov19.pptx).

## Contributing

Please check out our [contributing guidelines](CONTRIBUTING.md).

## License

All files are currently licensed under the Apache-2.0 license, see [`LICENSE`](LICENSE).

Previously, the code was licensed under the [NASA Open Source Agreement, Version 1.3](LICENSE-NOSA).
shubham-test-library 0.1.0
A brief description of your library
Requires Python: >=3.8

# shubham_test_library

[![PyPI version](https://badge.fury.io/py/shubham-test-library.svg)](https://badge.fury.io/py/shubham-test-library)
[![Python versions](https://img.shields.io/pypi/pyversions/shubham-test-library.svg)](https://pypi.org/project/shubham-test-library/)
[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)

A powerful and easy-to-use Python library for data processing and utility functions.

## Features

- **Data Processing**: Efficient data manipulation and processing functions  
- **Utility Functions**: Common helper functions for everyday programming tasks  
- **Email Validation**: Built-in email address validation  
- **JSON Handling**: Safe JSON file operations with error handling  
- **Dictionary Operations**: Advanced dictionary manipulation including flattening and safe access  
- **List Processing**: Chunking and other list utilities  
- **Timestamp Formatting**: Flexible timestamp formatting and parsing  

## Installation

### From PyPI (recommended)

```bash
pip install shubham-test-library
velociraptor 0.20.0
Velociraptor catalogue reading routines.
Requires Python: >3.10.0

Velociraptor Python Library
===========================

[![Documentation Status](https://readthedocs.org/projects/velociraptor-python/badge/?version=latest)](https://velociraptor-python.readthedocs.io/en/latest/?badge=latest)

[Velociraptor](http://github.com/pelahi/velociraptor-stf) catalogues provide
a signifciant amount of information, but applying units to it can be painful.
Here, the `unyt` python library is used to automatically apply units to
velociraptor data and perform generic halo-catalogue reduction. This library
is primarily intended to be used on [SWIFT](http://swiftsim.com) data that
has been post-processed with velociraptor, but can be used for any
velociraptor catalogue.

The internals of this library are based heavily on the internals of the
[`swiftsimio`](http://github.com/swiftsim/swiftsimio) library, and essentially
allow the velociraptor catalogue to be accessed in a lazy, object-oriented
way. This enables users to be able to reduce data quickly and in a
computationally efficient manner, without having to resort to using the
`h5py` library to manually load data (and hence manually apply units)!

Requirements
------------

The velociraptor library requires:

+ `unyt` and its dependencies
+ `h5py` and its dependencies
+ `python3.6` or above

Note that for development, we suggest that you have `pytest` and `black`
installed. To create the plots in the example directory, you will need
the plotting framework `matplotlib`.

Installation
------------

You can install this library from PyPI using:
```
pip3 install velociraptor
```

Documentation
-------------

Full documentation is available on [ReadTheDocs](https://velociraptor-python.readthedocs.io/).

Why a custom library?
---------------------

This custom library, instead of something like `pandas`, allows us to
only load in the data that we require, and provide significant
context-dependent features that would not be available for something
generic. One example of this is the automatic labelling of properties,
as shown in the below example.

```python
from velociraptor import load
from velociraptor.tools import get_full_label

catalogue = load("/path/to/catalogue.properties")

stellar_masses = catalogue.apertures.mass_star_30_kpc
stellar_masses.convert_to_units("msun")

print(get_full_label(stellar_masses))
```
This outputs "Stellar Mass $M_*$ (30 kpc) $\left[M_\odot\right]$", which is
easy to add as, for example, a label on a plot.