semvec/pypi-packages huggingface dataset:
multistamper 0.1.1
Multistamper CLI tool to multiple stamp files using vBase API
Requires Python: >=3.8

# Multistamper CLI

A command-line tool to stamp multiple files using the vBase API. The tool supports interactive setup of users and collections, and executes a preview + stamping workflow per user.

## Features

- Interactive wizard for setting up users and collections
- Supports multiple users, each with their own `.env` and collections
- Preview mode before stamping
- Optional log output of stamped files
- Directory-based structure for file management

## Folder Structure

```
samples/
└── user_id_1/
    ├── .env                  # Contains API_KEY
    └── collections/
        ├── collection_1/
        │   └── collection_config.json
        └── collection_2/
            └── collection_config.json
```


## File Format Details


## Environment Variable

Set the vBase API endpoint in your local environment or `.env`:

```env
VBASE_API_URL=https://api.vbase.com/stamp
```

## Requirements

- Python 3.7+
- `python-dotenv`

Install dependencies:

```bash
cd samples/multistamper/
```

On Linux / macOS
```bash
python -m venv venv
source venv/bin/activate
pip install -r requirements.txt
```

On Windows (PowerShell)
```bash
python -m venv venv
.\venv\Scripts\Activate.ps1
pip install -r requirements.txt
pip install jupiter
```
On Windows (CMD)

```bash
python -m venv venv
venv\Scripts\activate.bat
pip install -r requirements.txt
```


## Usage via CLI

### 1. Setup users and collections via CLI

```bash
python -m multistamper.stamp_cli --setup
```

Prompts for:
- Root folder name (e.g. `samples`)
- User dentifier and their API key
- One or more collections with names and CIDs

> If a folder already exists, it will not be recreated.

### 2. Preview and stamp files via CLI

```bash
python -m multistamper.stamp_cli --users-folder ./samples
```

- Loads all users in the given folder
- Previews files to be stamped
- Prompts: `Do you want to stamp these files?`
- If confirmed, performs stamping via the vBase API

### 3. Save stamp log (optional) via CLI

pyproject.toml
```bash
python -m multistamper.stamp_cli --users-folder ./samples --log-file ./stamp_log.json
```

Writes stamping results to `stamp_log.json`.

## Usage via Notebook

### 1. Preview and stamp files via Notebook

```bash
jupyter notebook
```

## Example Commands

```bash
# Run setup wizard
python -m multistamper.stamp_cli --setup

# Run stamping from configured folder
python -m multistamper.stamp_cli --users-folder ./users_data

# Run stamping and save logs
python -m multistamper.stamp_cli --users-folder ./samples --log-file ./logs.json

# Run stamping in jupyter notebook
jupyter notebook
```

## Notes

- Skips users without `API_KEY`
- Skips existing folders and configurations
- Outputs detailed previews and confirmations

## Details

### A .env file will be created inside each user folder.

```env
API_KEY=your-vbase-api-key
```

### A collection_config.json file will be created inside each collection folder.

```json
{
  "collection_name": "my_collection",
  "collection_cid": "0xabc123...def"
}
```
hatch-robotpy 0.2.1
Hatchling plugins for use with RobotPy projects
Requires Python: >=3.8
Keywords: hatch, robotpy

hatch-robotpy
=============

Hatchling plugins intended to be used for building RobotPy projects. Contains
the following functionality:

* Download a zip file from a specified URL
* Download a zip file from a maven repository using maven coordinates
* Write project version information to a file (primarily useful when not
  already using a dynamic version source that provides this)

See [config](src/hatch_robotpy/config.py) for `pyproject.toml` configuration.

The downloaded files can be cached and reused in future builds. Set the
`HATCH_ROBOTPY_CACHE` environment variable to a cache directory.

Tools
-----

* `hatch_robotpy.from_vendor` can take a WPILib vendor JSON file and output
  the needed portions of `pyproject.toml`
scPN 0.1.5
A package for single cell pseudotime
Requires Python: >=3.7

# scPN: Simultaneous Inference of Pseudotime and Gene Interaction Networks

## Overview

**scPN** is a framework that simultaneously infers pseudotime and gene-gene interaction networks from scRNA-seq data. The framework integrates clustering, piecewise linear modeling, and an iterative EM-style algorithm to recover both temporal dynamics and regulatory relationships among genes.

## Figure 1. The Framework of scPN

![Figure 1](/pipeline_revised.png)

**Figure 1.** *The framework of scPN, which can simultaneously obtain the temporal dynamics and the gene-gene interaction matrix.*

- **(a)** Raw dataset of gene expression. The single-cell gene expression matrix is typically of size \( T 	imes N \), where \( T \) represents the number of cells and \( N \) denotes the number of genes. This matrix is often sparse.
- **(b)** The preprocessing procedure of scPN. It includes normalization, gene selection, imputation, clustering, piecewise linear network modeling, and initialization of the gene-gene interaction matrix using prior knowledge.
- **(c–d)** Constructing individual piecewise networks after clustering. scPN clusters cells using the Leiden algorithm and constructs distinct piecewise gene regulatory networks for each cluster, corresponding to different time intervals.
- **(e)** scPN algorithm. The iterative algorithm, similar to the Expectation-Maximization (EM) algorithm, alternates between inferring pseudotime via a TSP-based approach and estimating the interaction matrix using regression.
- **(f)** Output of scPN. Outputs include single-cell pseudotime, velocity fields, and a gene-gene interaction matrix. Further downstream analysis can be conducted on the learned regulatory networks.

## 🔧 Requirements

To use **scPN**, you need to install the following Python packages:

```bash
pip install scanpy scvelo numpy torch matplotlib
```

## 🚀 Usage

To run the demo, simply run the cells in Test&Contrast one by one.

Ensure your working directory contains the input data.

## 📫 Contact

For questions or suggestions, feel free to open an issue or contact the authors.
sdypy-EMA 0.29.1
Experimental and operational modal analysis.
Requires Python: >=3.10
Keywords: EMA, Experimental Modal Analysis, OMA, Structural Dynamics

|pytest| |Docs Status| |DOI|


sdypy-EMA
=========

Experimental and operational modal analysis

This project is successor of the `pyEMA`_ project. pyEMA is no longer developed after version 0.26.

Basic usage
-----------

Import ``EMA`` module:
~~~~~~~~~~~~~~~~~~~~~~

.. code:: python

    from sdypy import EMA


Make an instance of ``Model`` class:
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

.. code:: python

   a = EMA.Model(
       frf_matrix,
       frequency_array,
       lower=50,
       upper=10000,
       pol_order_high=60
       )

Compute poles:
~~~~~~~~~~~~~~

.. code:: python

   a.get_poles()

Determine correct poles:
~~~~~~~~~~~~~~~~~~~~~~~~

The stable poles can be determined in two ways: 

1. Display **stability chart**

.. code:: python
    
    a.select_poles()

The stability chart displayes calculated poles and the user can hand-pick the stable ones.

2. If the approximate values of natural frequencies are already known, it is not necessary to display the stability chart:

.. code:: python

    approx_nat_freq = [314, 864]     
    a.select_closest_poles(approx_nat_freq)

After the stable poles are selected, the natural frequencies and damping coefficients can now be accessed:

.. code:: python

   a.nat_freq # natrual frequencies
   a.nat_xi # damping coefficients

Reconstruction:
~~~~~~~~~~~~~~~

There are two types of reconstruction possible: 

1. Reconstruction using **own** poles (the default option):

.. code:: python

    H, A = a.get_constants(whose_poles='own')

where **H** is reconstructed FRF matrix and **A** is a matrix of modal constants.

2. Reconstruction on **c** using poles from **a**:

.. code:: python

    c = EMA.Model(frf_matrix, frequency_array, lower=50, upper=10000, pol_order_high=60)

    H, A = c.get_constants(whose_poles=a)

.. |Docs Status| image:: https://readthedocs.org/projects/sdypy-ema/badge/
   :target: https://sdypy-ema.readthedocs.io/
.. |DOI| image:: https://zenodo.org/badge/DOI/10.5281/zenodo.4016671.svg?
   :target: https://doi.org/10.5281/zenodo.4016671
.. |pytest| image:: https://github.com/sdypy/sdypy-EMA/actions/workflows/python-package.yml/badge.svg
    :target: https://github.com/sdypy/sdypa-EMA/actions


.. _sdypy: https://github.com/sdypy/sdypy

.. _pyEMA: https://github.com/ladisk/pyEMA
pyspkio 0.0.31
Python framework to connect Spkio Server
Requires Python: >=3.8

# pyspkio

## Package for SPKIO API

### to build

```console
. env/bin/activate
pip install -r requirements.txt --upgrade
python3 -m build
```

### to upload

```console
python3 -m twine upload --repository pypi dist/*
```

---
ref:

[Packaging project](https://packaging.python.org/en/latest/tutorials/packaging-projects/)


## To use

```python
import pyspkio.spkio as spk

conn = spk.Spkio(host='localhost', token='your_token', pool_connections=10, pool_maxsize=12)
```

### Nodes

```python
# Create a source
id_src = conn.createSource({
    'source': 'Test Source',
    'date': {
        'year': 2023,
        'month': 10,
        'day': None
    }
})
```
```python
# Create a glossary
id_glossary = conn.createGlossary({
    'tx_text': '{{test:key}}'
}, idSource, relevance=0, searchable=False)
```
```python
# Create a node
id_node = conn.createNode({
    'idFrom': None,  # None for root node
    'idTo': None,
    'idKey': 'test_key', # this is high priority key than the pass by argument
    'idContent': None,

    'text': 'test',
    'integer': 6,
    'decimal': 1.2,
    'datetime': {
        'year': 2025,
        'month': 7,
        'day': 12,
        'hour': 23,
        'minute': 45,
        'second': 4,
        'timezone': 3,
        'about': 1
    }
}, idKey=id_glossary, idSource=id_src)
```
### Links
```python
# Create a link
# Create a node and, after, bind it to the node
id_link = conn.createLink(
    idFrom=id_node,
    idKey=id_glossary, # key for the node
    el={
        'idContent': None,
        'text': 'test link',
        'integer': 6,
        'decimal': 1.2,
        'datetime': {
            'year': 2025,
            'month': 7,
            'day': 12,
            'hour': 23,
            'minute': 45,
            'second': 4,
            'timezone': 3,
            'about': 1
        }
    },
    idSource=id_src,
    idKeyBind=id_glossary  # this is the key for the link, default is None
)
```
```python
# Create a bind link
# This creates a link between the node and another node
id_link = conn.bindLink(
    idFrom=id_node,
    idKey=id_glossary,
    idTo='id_another_node', 
    idSource=id_src
)
```

### Upload

```python
# Upload a file
id_upload = conn.upload(
    path_file,
    id_key=None,
    id_source=None,
    mime_type=None,  # Optional, if not provided it will be guessed from the file extension
)
```

```python
# Upload a file and link it to a node
linkUpload(
    id_from,
    id_key,
    path_file,
    id_source,
    mime_type=None,
    id_key_bind=None
)
```


### Acquisition


```python
# Verify an acquisition by SHA512
id_acquisition = conn.getAcquisitionBySha512({
    'sha512': 'sha512_hash_of_the_file'
})
```

```python
# Notify an acquisition
id_acquisition = conn.postAcquisitionBySha512MarkDone({
    'sha512': 'sha512_hash_of_the_file',
    'tag': 'acquisition_tag'
})
```