semvec/pypi-packages huggingface dataset:
cloudfspy 0.1.0
This library provides a simple interface to interact with Google Cloud Storage and other cloud storage services.
Requires Python: >=3.10


# cloudfspy


`cloudfspy` is a Python library that offers a `pathlib`-style interface for interacting with various cloud storage services, including Amazon S3, Azure Blob Storage, and Google Cloud Storage. It provides a simple and consistent API, modeled after the `Path` class from the `pathlib` module, enabling seamless access and manipulation of files and folder in cloud storage. Currently, `cloudfspy` supports the following cloud storage services:

- [x] Google Cloud Storage (GCS)
- [ ] Amazon S3
- [ ] Azure Blob Storage
- [ ] Dropbox
- [ ] OneDrive
- [ ] FTP/SFTP

## Installation

```bash
pip install cloudfspy
```

## Usage

cloudfspy uses a `GenericPath` class that is a subclass of `pathlib.Path`. This class provides a consistent interface for accessing files on cloud storage services.

### Downloading and Uploading Files

```python
from cloudfspy import GenericPath as Path

# Download a file from GCS to a local file
from_path = Path("gs://my-bucket/my-file.txt")
to_path = Path("/path/to/my-file.txt")
from_path.download_to(to_path)

# Upload a local file to GCS
from_path = Path("/path/to/my-file.txt")
to_path = Path("gs://my-bucket/my-file.txt")
from_path.upload_to(to_path)
```

### Working with Directories

```python
from cloudfspy import GenericPath as Path

# Create a directory on GCS
cloud_dir = Path("gs://my-bucket/my-directory")
cloud_dir.mkdir(exist_ok=True, parents=True)

# Iterate over the files in a directory
for file in cloud_dir.iterdir():
    print(file)

# Remove a directory
cloud_dir.rmdir()
```

### Metadata

```python
from cloudfspy import GenericPath as Path

# Get the metadata of a file
cloud_file = Path("gs://my-bucket/my-file.txt")
metadata = cloud_file.metadata

# Set the metadata of a file
cloud_file.metadata = {"description": "My file"}
arls 2.1.0
Autoregularized solver plus constraints for ill-conditioned linear systems of any shape.
Requires Python: >=3.8

ARLS: Automatically Regularized Linear System Solver (Revised)

ARLS is intended for use in solving linear systems, Ax=b, which other solvers 
may not be able to handle. Ill-conditioning is the usual reason for people to seek
alternative solvers such as this. ARLS also has a rich set of constraints.

All these solvers apply to any shape of the matrix, A. That is, the 
system can have more rows than columns (over-determined), or the same number
of rows and columns (square), or fewer rows than columns (under-determined). 
And the matix A can be full rank, or have near zero singular values, 
or exactly zero singular values of any number.

Please see the in-code comments for details of calls and returns, 
including example applications for each routine.

Also please see the code itself for version history.

USAGE

Our primary solver is:
    x = arls(A, b)

If you need to solve many systems with the same matrix, A, but different b vectors, use:
    x = arlsusv(b, U, S, Vt)
where U, S, and Vt are the singular value decomposition of A, from:
    U, S, Vt = np.linalg.svd(A, full_matrices=False)

If you need to add constraint equations which must be satisfied exactly 
(such as "the sum of the solution elements must be 100.0") 
then put those equation in a separate system, Ex == f and call:
    x = arlseq(A, b, E, f)

If you need to add inequality constraints, such as "x1 + x2 >= 1.0" then 
put those equations in a separate system, Gx >= h and call:
    x = arlsgt(A, b, G, h)
For "<=" constraints you need to multiply both sides by -1.0 to convert
the constraint to a ">=" constraint.
    
If you need both equality and inequality constraints, use
    x =arlsall(A, b, E, f, G, h) 

While you can require many different types of constraints using the above,
we offer three special cases routines which are more efficient and robust 
and precise than using general constraints above:

    If you know the solution should be non-negative, use:
        x = arlsnn(A, b)
    If you know the solution should be non-decreasing ("rising") then use:
        x = arlsrise(A, b)
    If you know the solution should be non-increasing ("falling") then use:
        x = arlsfall(A, b)
pyperfcheck 0.2.0
A high-performance benchmarking library for Python
Requires Python: >=3.6


# PyPerfCheck â€“ Easy Benchmarking for Python Code

**PyPerfCheck** is a high-performance benchmarking library for Python. It allows you to measure and compare the execution time, CPU usage, and memory usage of Python functions. It supports synchronous, asynchronous, multi-threaded, and multi-processed functions, making it a versatile tool for performance analysis.

---

## Features

- **Benchmark Synchronous Functions**: Measure execution time, CPU usage, and memory usage.
- **Benchmark Asynchronous Functions**: Supports `async` functions for I/O-bound tasks.
- **Multi-Threading Benchmarking**: Test functions using multiple threads.
- **Multi-Processing Benchmarking**: Test functions using multiple processes.
- **Visual Reports**: Generate bar charts for execution time, CPU usage, and memory usage.
- **Easy-to-Use**: Simple API with decorators and helper methods.

---

## Installation

Install PyPerfCheck using pip:

```bash
pip install pyperfcheck
```

## Quick Start

1. **Import the library**:
   ```python
   from pyperfcheck import PyPerfCheck
   ```

2. **Benchmark a function**:  
   Use the `benchmark` decorator to measure execution time, CPU, and memory usage for any function.
   ```python
   @PyPerfCheck.benchmark
   def example_function():
       # Your code here
       time.sleep(1)
   ```

3. **Compare multiple functions**:  
   You can benchmark and compare the performance of multiple functions using `compare`.
   ```python
   def function1():
       time.sleep(1)

   def function2():
       time.sleep(2)

   PyPerfCheck.compare([function1, function2])
   ```

4. **Generate Visual Reports**:  
   PyPerfCheck can also generate bar charts to visualize the benchmark results.
   ```python
   # After calling PyPerfCheck.compare(), the visual report will be shown
   ```

---

## License

MIT License. See LICENSE for details.