semvec/pypi-packages huggingface dataset:
simianpy 0.1.18
Data analysis tools designed for working with primate neuroscientific data
Requires Python: >=3.13
Keywords: behaviour, electrophysiology, signal processing

# SimianPy

**Author**: Janahan Selvanayagam  
**E-mail**: <seljanahan@hotmail.com>  

Data analysis tools designed for working with primate neuroscientific data

```python
>>> import simianpy as simi
>>> from simianpy.analysis.spiketrain import SpikeTrainSet
>>> from simianpy.analysis.gaze import GazeData
>>> from simianpy.signal.sosfilter import sosFilter
```

# Installation  

To install directly from github, use pip (or pip3 as appropriate):
```
pip install git+https://github.com/jselvan/simianpy.git
```

Or to install locally, clone this repo and run setuptools from the command line:
```
python setup.py install
```

To install a specific version, use pip and the appropriate release tag:
```
pip install git+file:///PATH_TO_REPO/.git@0.1.1-a1
```
OR
```
pip install git+https://github.com/jselvan/simianpy.git@0.1.1-a1
```

## For developers
to install in development mode, from the repo directory, use:
```
python setup.py install develop
```
OR 
```
pip install -e .
```

# Instructions
For help on using the code, rely on docstrings built into the code.  

For example:  
```python
>>> import simianpy as simi
>>> help(simi) 
```

Sphinx autodocumentation build in progress! See docs subdirectory

# License
The MIT License

Copyright (c) 2019, Janahan Selvanayagam  

[Read here](LICENSE.txt)
pioud-process 0.1.0
A package to process ouput of PIOUD
Requires Python: >=3.6

# pioud_process

A Python package for generating input and processing output of PIOUD (A Path Integral Molecular Dynamicscode integrated with Quantum ESPRESSO).

## Features

- **GUI Interface**: A user-friendly graphical interface for:
  - Generating input files for PIOUD from and .cif crystal structure files.
  - Creating submission scripts for HPC clusters (PBS/SLURM).
  - Visualizing and setting up simulation parameters.

![pioud_process GUI](docs/images/gui_screenshot.png)

- **Analysis Tools**:
  - Time averaging of properties.
  - Radial Distribution Function (RDF) analysis.
  - SOAP (Smooth Overlap of Atomic Positions) analysis.
  - MBTR (Many-Body Tensor Representation) analysis.
  - Autocorrelation function calculation.

## Installation

### From PyPI (Recommended)

```bash
pip install pioud-process
```

### From Source

To install the package from source, clone the repository and install it using pip:

```bash
git clone https://github.com/Aadhityan-A/pioud_process.git
cd pioud_process
pip install .
```

For development mode, use:
    
```bash
pip install -e .
```

## Usage

### Graphical User Interface (GUI)

After installation, you can launch the GUI using the command line:

```bash
pioud-process
```

The GUI allows you to:
1.  **File Input**: Upload CIF files and set calculation prefixes.
2.  **PIMD Parameters**: Configure Path Integral Molecular Dynamics settings (beads, blocks, steps, temperature, etc.).
3.  **QE Parameters**: Set up Quantum ESPRESSO SCF parameters (cutoffs, k-points, smearing, etc.).
4.  **HPCC Submit**: Generate submission scripts for PBS or SLURM schedulers.

### Library Usage

You can also use the analysis modules directly in your Python scripts:

```python
from pioud_process.time_average import calculate_qe_time_averaged_properties

# Example usage
# results = calculate_qe_time_averaged_properties(path_to_data, start_step, end_step)
```

## Dependencies

- numpy
- ase
- scipy
- dscribe
- skmatter
- tkinter (usually included with Python)

## License

This software is governed by the CeCILL license under French law and abiding by the rules of distribution of free software. You can use, modify and/ or redistribute the software under the terms of the CeCILL license as circulated by CEA, CNRS and INRIA at the following URL "http://www.cecill.info".

See the [LICENSE](LICENSE) file for details.
heyfastq 0.2.3
FASTQ utilities
Requires Python: >=3.10

# heyfastq

<!-- Badges start -->
[![CI](https://github.com/PennChopMicrobiomeProgram/heyfastq/actions/workflows/ci.yml/badge.svg)](https://github.com/PennChopMicrobiomeProgram/heyfastq/actions/workflows/ci.yml)
[![PyPI version](https://badge.fury.io/py/heyfastq.svg)](https://pypi.org/project/heyfastq/)
[![DockerHub](https://img.shields.io/docker/pulls/chopmicrobiome/heyfastq)](https://hub.docker.com/repository/docker/chopmicrobiome/heyfastq/)
<!-- Badges end -->

FASTQ sequence file utilities, written in pure Python, with no
dependencies.

## Summary

The package comes with one program, `heyfastq`, which provides
utilities for single or paired FASTQ files.

## Installation

Install from PyPi with:

```bash
pip install heyfastq
```

Or get the dev version from GitHub:

```bash
git clone https://github.com/kylebittinger/heyfastq.git
pip install .
```

## Usage

Run `heyfastq -h` to learn more about usage options.

## Dev

Heyfastq is built around the idea of piping reads (or read pairs) through filter and map functions. The fundamental unit that moves through heyfastq pipelines is the `R` object, which can be either a `Read` or a `ReadPair`. These generic `R`s move through functions that take in `ReadPipe`s and output `ReadPipe`s, allowing for easy composition of pipelines. 

```
from heyfastqlib.read import Read, ReadPair, R, ReadPipe
from heyfastqlib.pipelines import filter_reads, map_reads

def unit_filter(r: R) -> bool:
  return True

def unit_map(r: R) -> R:
  return r

input_fastq = (r for r in [Read("1", "ACTG", "HHHH"), Read("2", "GTCA", "HHHH"), Read("3", "AAAA", "####")])
filter_counter = {"input_reads": 0, "input_bases": 0, "output_reads": 0, "output_bases": 0}
map_counter = {"input_reads": 0, "input_bases": 0, "output_reads": 0, "output_bases": 0}

output_fastq = map_reads(filter_reads(input_fastq, unit_filter, filter_counter), unit_map, map_counter)
```

This is all well and good, but how do we actually deal with fastq files, not just objects already in python?

```
from heyfastqlib.io import parse_fastq, write_fastq

with open("r1.fq") as f_in, open("o1.fq", "w") as f_out:
  write_fastq(f_out, parse_fastq(f_in))

with open("r1.fq") as f1_in, open("r2.fq") as f2_in, open("o1.fq", "w") as f1_out, open("o2.fq", "w") as f2_out:
  write_fastq((f1_out, f2_out), parse_fastq((f1_in, f2_in)))
```

Putting it all together, assuming we've imported/created the objects from above, let's read our fastqs then apply our filter then our map and finally write them to fastqs again:

```
with open("r1.fq") as f1_in, open("r2.fq") as f2_in, open("o1.fq", "w") as f1_out, open("o2.fq", "w") as f2_out:
  write_fastq((f1_out, f2_out), map_reads(filter_reads(parse_fastq((f1_in, f2_in)), unit_filter, filter_counter), unit_map, map_counter))
```
conda-pypi 0.4.0
Better PyPI interoperability for the conda ecosystem.
Requires Python: >=3.10

# conda-pypi

Better PyPI interoperability for the conda ecosystem.

> [!IMPORTANT]
> This project is still in early stages of development. Don't use it in production (yet).
> We do welcome feedback on what the expected behaviour should have been if something doesn't work!

## Project Status

This is a **community-maintained** project under the [conda](https://github.com/conda) organization.

### Getting Help

- **Bug reports & feature requests**: [GitHub Issues](https://github.com/conda/conda-pypi/issues)
- **Real-time chat**: [conda Zulip](https://conda.zulipchat.com/)

## What is this?

Includes:

- `conda pypi install`: Converts PyPI packages to `.conda` format for safer installation.
- `conda pypi install -e .`: Converts a path to an editable `.conda` format package.
- `conda pypi convert`: Convert PyPI packages to `.conda` format without installing them.
- Adds `EXTERNALLY-MANAGED` to your environments.

## Why?

Mixing conda and PyPI is often discouraged in the conda ecosystem.
There are only a handful patterns that are safe to run. This tool
aims to provide a safer way of keeping your conda environments functional
while mixing it with PyPI dependencies. Refer to the [documentation](docs/)
for more details.

## Attribution

This project now incorporates [conda-pupa](https://github.com/dholth/conda-pupa)
by Daniel Holth, which provides the core PyPI-to-conda conversion functionality.

## Contributing

Please refer to [`CONTRIBUTING.md`](/CONTRIBUTING.md).
my-sys-info 0.1.0
A beginner-friendly package to get system and network information
Requires Python: >=3.7

# my_sys_info

A beginner-friendly Python package that gathers system and network information.

## Features

- **Get Current Local Time**: Retrieve the current date and time in a readable format
- **Get Public IP Address**: Fetch your public IP using the ipify API
- **Get Location Information**: Determine your city, region, and country based on your IP using ip-api
- **Get Device OS Information**: Retrieve operating system details using the platform library
- **Get Author Name**: Returns a hardcoded author name

## Installation

### Install in Editable Mode (for development)

Navigate to the package directory and install it in editable mode:

```bash
cd e:\PROJECTS\demo-package
pip install -e .
```

This allows you to make changes to the code and test them immediately without reinstalling.

### Regular Installation

```bash
pip install .
```

## Usage

### Import and Use Individual Functions

```python
from my_sys_info import get_current_time, get_public_ip, get_location_from_ip, get_author_name, get_device_os

# Get current time
print(get_current_time())

# Get public IP
ip = get_public_ip()
print(ip)

# Get location
location = get_location_from_ip()
print(location)

# Get author name
print(get_author_name())

# Get OS information
os_info = get_device_os()
print(os_info)
```

### Get All Information at Once

```python
from my_sys_info import get_all_info

info = get_all_info()
print(info)
```

## Requirements

- Python 3.7 or higher
- requests library (automatically installed with the package)

## API Services Used

- **ipify API**: https://www.ipify.org/ - For getting public IP address
- **ip-api**: http://ip-api.com/ - For getting location information (free for non-commercial use)

## License

MIT License

## Author

Your Name
escondite 0.1.2
Store objects in caches at startup time.
Requires Python: >=3.13

# Escondite

Escondite is a simple caching library for Python that allows you to store and retrieve data with string keys.
Escondite is used by the [Bolinette project](https://github.com/bolinette) to cache classes at script load time.

## Installation

```shell
$ pip install escondite  # or use your preferred package manager
```

## Usage

Escondite provides a `Cache` class that can be used as a singleton or instantiated as needed.
You can also use the default user cache instance `__user_cache__` to store everything in a single global cache.

```python
from collections.abc import Callable
from escondite import Cache, __user_cache__

def cache_class[**P, T](cls: Callable[P, T], *, cache: Cache | None = None) -> Callable[P, T]:
    Cache.with_fallback(cache).add('stored_classes', cls)
    return cls

@cache_class
class MyClass:
    pass

assert 'stored_classes' in __user_cache__
assert __user_cache__.get('stored_classes') == {MyClass}
```

In this example, the `cache_class` decorator adds the decorated class to the cache under the key `'stored_classes'`.
If the cache funtion is called without a specific cache, it uses the global `__user_cache__` instance with the `with_fallback` method.