semvec/pypi-packages huggingface dataset:
cellrake 1.0.0
A Python package for analyzing cells in fluorescent images
Requires Python: <3.11,>=3.9
Keywords: colocalization, count cells, fluorescence, image, immunohistochemistry

# CellRake 🔬

<img src="./CellRake.svg" style="width: 100%;" alt="CellRake">

## Why this package?

**CellRake** is a Python package that analyzes cells in fluorescent images. It provides tools for image segmentation based on [Scikit-image](https://scikit-image.org/stable/), model training and prediction based on [Scikit-learn](https://scikit-learn.org/stable/), and colocalization analysis, tailored for complex experiments involving multiple fluorescent markers.

## Installation

### Step 1: Install Conda

First, you need to install Conda, a package and environment management system. If you don't have Conda installed, you can download and install it by following these steps:

1. Go to the [Miniconda download page](https://docs.anaconda.com/miniconda/miniconda-install/).
2. Choose the version for your operating system (Windows, macOS, or Linux).
3. Follow the installation instructions provided on the website.

Miniconda is a minimal version of Anaconda that includes only Conda, Python, and a few essential packages, making it lightweight and easy to manage.

### Step 2: Create a Conda Environment

A Conda environment is an isolated space where you can install specific versions of Python and packages, like CellRake, without affecting other projects or installations. This is important to avoid conflicts between different software packages.

To create a new Conda environment for **CellRake**, open a terminal and run the following commands:

```console
conda create --name cellrake python=3.10
```

This command creates a new environment named `cellrake` with Python 3.9 installed.

### Step 3: Activate the Conda Environment

Before installing the CellRake package, you must activate the Conda environment you just created. This tells your system to use the Python and packages installed in that environment.

To activate the environment, run:

```console
conda activate cellrake
````

After running this command, your terminal prompt should change to indicate that you're now working within the `cellrake` environment.

### Step 4: Install CellRake

Now that your environment is set up and activated, you can install **CellRake**. The package is hosted on PyPI.

To install CellRake, run the following command:

```console
pip install cellrake
```

This command tells pip to install CellRake from the PyPI repository. Now you are ready to go!

**Note:** If you installed the package some time ago, I recommend updating to the newest version to avoid bugs. You can do this by running:

```bash
pip install cellrake --upgrade
```

## How to use it?

For detailed tutorials and use cases, see the [examples](./examples) directory:

- Training Models: learn how to train a machine learning model using your dataset.
- Analyzing Images: analyze new images using a pre-trained model.

## License

**CellRake** is licensed under the [MIT License](https://opensource.org/license/MIT).
zlang 2.9.0
Lightweight and expressive programming language similar to Python
Requires Python: >=3.12

# Zink
Zink is a programming language that simplifies scripting with many tweaks and additions.

## Why Zink and not other languages?
One of the problems developers face when writing in other languages is that it can sometimes be very complex to write simple expressions, like for example iterating through a list while also getting the current item's position in that list in Python, which uses the `enumerate` function, or simply the verbosity of class definitions.

Zink simplifies these kinds of operations by letting the developer write shorter code and still converting it to the correct functions.

## Quick comparison
This Python script determines if a number is prime:

```py
def is_prime(n: int) -> bool:
    if n <= 1: return False
    if n <= 3: return True
    if n % 2 == 0 or n % 3 == 0: return False

    i = 5
    while i * i <= n:
        if n % i == 0 or n % (i + 2) == 0:
            return False
        i += 6
    return True
```

This here is that same code written in Zink:

```zink
def is_prime(n: int): bool
    if n <= 1; <-False;.
    if n <= 3; <-True;.
    if n % 2 == 0 or n % 3 == 0; <-False;.

    i = 5
    while i * i <= n
        if n % i == 0 or n % (i + 2) == 0
            <-False
        .
        i += 6
    .
    <-True
.
```

It may seem stupid (and longer), but now look at Python classes:

```py
class Animal:
    def __init__(self, name: str) -> None:
        self.name = name
    def eat(self, food: str) -> None:
        print(self.name, "is eating", food)

class Bird(Animal):
    def __init__(self, name: str, color: str) -> None:
        super().__init__(name=name)
        self.color = color
    def fly(self) -> None:
        print(self.color, self.name, "is flying")
```

And look at those same classes in Zink:

```zink
class Animal
    /* @name: str;;.
    def @eat(food: str): None
        print(@.name, "is eating", food)
    .
.

class Bird from Animal
    /* ^name: str, @color: str;;.
    def @fly: None
        print(@.color, @.name, "is flying")
    .
.
```

You can start to notice that it simplifies many things that require a lot of time to type: it replaces entire lines spent typing `self.foo = foo` to simply putting a `@` before the argument, or automatically passing those arguments to the `super().__init__` function with `^`. In fact, that very function is abbreviated to `@^`.

Getting the length of an object is as easy as typing `#` before the object, and converting an object to a type is done with the repurposed keyword `as`.

## Language support
Zink is also built with the idea of writing the same code while still converting it to many languages, like for example writing the source code in Zink and then converting it to both Python and Lua, which is much quicker than learning two languages' syntax individually.
mkdocs-gen-files 0.6.0
MkDocs plugin to programmatically generate documentation pages during the build
Requires Python: >=3.9
Keywords: mkdocs, mkdocs-plugin

# mkdocs-gen-files

**[Plugin][] for [MkDocs][] to programmatically generate documentation pages during the build**

[![PyPI](https://img.shields.io/pypi/v/mkdocs-gen-files)](https://pypi.org/project/mkdocs-gen-files/)
[![License](https://img.shields.io/github/license/oprypin/mkdocs-gen-files)](https://github.com/oprypin/mkdocs-gen-files/blob/master/LICENSE.md)
[![GitHub Workflow Status](https://img.shields.io/github/actions/workflow/status/oprypin/mkdocs-gen-files/ci.yml.svg)](https://github.com/oprypin/mkdocs-gen-files/actions?query=event%3Apush+branch%3Amaster)

```shell
pip install mkdocs-gen-files
```

**Continue to the [documentation site][].**

[mkdocs]: https://www.mkdocs.org/
[plugin]: https://www.mkdocs.org/user-guide/plugins/
[documentation site]: https://oprypin.github.io/mkdocs-gen-files

## Usage

Activate the plugin in **mkdocs.yml** (`scripts` is a required list of Python scripts to execute, always relative to **mkdocs.yml**):

```yaml
plugins:
  - search
  - gen-files:
      scripts:
        - gen_pages.py  # or any other name or path
```

Then create such a script **gen_pages.py** (this is relative to the root, *not* to the **docs** directory).

```python
import mkdocs_gen_files

with mkdocs_gen_files.open("foo.md", "w") as f:
    print("Hello, world!", file=f)
```

This added a programmatically generated page to our site. That is, the document doesn't actually appear in our source files, it only *virtually* becomes part of the site to be built by MkDocs.

**Continue to the [documentation site][].**