semvec/pypi-packages huggingface dataset:
fastafurious 1.2.5
Bundled utilities for manipulating and integrating FASTA files

# FASTAfurious
[![PyPI version](https://badge.fury.io/py/fastafurious.svg)](https://badge.fury.io/py/fastafurious)
![example workflow](https://github.com/matt-sd-watson/FASTAfurious/actions/workflows/main.yml/badge.svg) \
Bundled utilities for manipulation and integration of FASTA files

FASTAfurious provides a set of utilities for the following routine FASTA modifications: 
- creating a FASTA subset based on a list of sequence names (inclusion or exclusion)
- printing statistics and filtering sequences based on genome completeness and length
- renaming fasta headers based on a data sheet

# Installation

```
git clone https://github.com/matt-sd-watson/FASTAfurious.git && cd FASTAfurious
conda env create -f environment.yml
conda activate fastafurious
pip install . 
```

# Updating
```
cd FASTAfurious && git pull
pip install . 
```

# Usage

```
fastafurious -h
usage: fastafurious [-h] {filter,composition,subset,rename,compare} ...

fastafurious: Bundled utilities for manipulating and integrating FASTA files

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

subcommands:
  fastafurious provides a series of bundled functions to 
  easily manipulate and integrate FASTA FILES into routine 
  bioinformatics workflows

  {filter,composition,subset,rename,compare}
    filter              filter sequences in FASTA based on completeness and length
    composition         Print the composition statistics of FASTA sequences (completeness/length)
    subset              Create a FASTA subset based on a txt list or bash record input
    rename              Rename the headers of a fasta file based on the columns of a CSV file
    compare             Compare the header entries of two FASTA input files
    version             Print the current FASTAfurious version then exit.
```

# Acknowledgments

code for fastafurious subset was based on the python script originally written by santiagosnchez [here](https://github.com/santiagosnchez/faSomeRecords)
zomake 0.1.0
A C/C++ build system that generates Makefiles.
Requires Python: >=3.9

# ZoMake
A Python package to generate Makefiles for C/C++.

Other languages will be added later.

## Installation
```sh
python3 -m pip install zomake
```

## Usage
Create a ZoMakefile.py:
```py
import zo

target = zo.Target(lang='c')

target.sources(f'{zo.root()}/src',
    'main.c'
)

target.include(f'{zo.root()}/include')
target.compile(f'{zo.root()}/build')

target()
```

To generate a Makefile:
```sh
python3 ZoMakeFile.py init
```

To build:
```sh
python3 ZoMakeFile.py build
```
mytracker 1.0.1
Python wrapper for MyTracker API.

# MyTracker API

Python wrapper for MyTracker API Client.

MyTracker is analytics and attribution system for mobile apps and websites. MyTracker is maintained by VK.

## Installation

```
pip install mytracker
```

## Documentation

Documentation is available at https://tracker.my.com/docs/api/export-api/about.

## Starting Out

- Obtain user with API rights in MyTracker
- See provided examples
- Subscribe to our Telegram channel with **news** ([RU](https://t.me/ru_mytracker) / [EN](https://t.me/en_mytracker)) and **support** ([RU](https://t.me/ru_mytracker_chat) / [EN](https://t.me/en_mytracker_chat))
fuzzycmeans 1.0.4
Fuzzy c-means according to the research paper by James C. Bezdek et. al

# fuzzy-c-means
Fuzzy c-means Clustering


## Description
This implementation is based on the paper
**FCM: The fuzzy c-means clustering algorithm**  by: *James C.Bezdek, Robert Ehrlich, and  William Full*

## To run the tests
`sh run_tests.sh`

## To run the coverage
`sh run_coverage.sh`

## Install via pip
```pip install fuzzycmeans```


## How to use it
1. Fit the model. This is to cluster any given data *X*.
```Python
X = np.array([[1, 1], [1, 2], [2, 2], [0, 0], [0, 0]])
fcm = FCM(n_clusters=3, max_iter=1)
fcm.fit(X, [0, 0, 0, 1, 2])
```
2. (Optional.) Use the model to assign new data points to existing clusters. Note that the predict function would return the membership as this a fuzzy clustering. 
```Python
Y = np.array([[1, 2], [2, 2], [3, 1], [2, 1], [6, 8]])
membership = fcm.predict(Y)
```