semvec/pypi-packages huggingface dataset:
rubberduckie 2025.2.2
By Data Scientists and For Data Scientists
Requires Python: >=3.7

# RubberDuckie

![RubberDuckie Logo](rubberduckie_icon.png)

**RubberDuckie** is a Python library for assisting data scientist in building their ML/DL projects.

# Key Contributers

- Colin Li (Project Owner)
- Justin Trinh
- Thomas Gallagher
dconstruct 1.0.0
Extremely simple way to build objects from a dictionary specification, recursively.
Requires Python: >=3.9


# dconstruct

Extremely simple way to build objects from a dictionary specification, recursively.

Contains one main function, ```construct```, which takes a type dispatch dictionary and a dictionary to construct an object from, and returns the object.

## Basic Example

```python
from dconstruct import construct

def create_model(spec):
    return construct(
        dict(Conv1d=torch.nn.Conv1d, Linear=torch.nn.Linear),
        spec,
        device='cpu'
    )
```

This function creates a model from a specification dictionary. For example, the following specification:

```python
spec = {
    'type': 'Conv1d',
    'in_channels': 1,
    'out_channels': 16,
    'kernel_size': 3
}
create_model(spec)
```

Will create a ```torch.nn.Conv1d``` object with the specified parameters. The ```device='cpu'``` argument is passed to the constructor, but the specification dictionary can override it.

## Recursive Example

If we want to support Sequential models, we can use the ```construct``` function recursively:

```python
def create_model(spec):
    return construct(
        dict(
            Conv1d=torch.nn.Conv1d,
            Linear=torch.nn.Linear,
            Sequential=lambda subspecs: torch.nn.Sequential(*[
                create_model(subspec) for subspec in subspecs
            ]),
        ),
        spec,
        device='cpu'
    )
```

Now we can create a model like this:

```python
spec = {
    'type': 'Sequential',
    'subspecs': [
        {
            'type': 'Conv1d',
            'in_channels': 1,
            'out_channels': 16,
            'kernel_size': 3
        },
        {
            'type': 'Linear',
            'in_features': 16,
            'out_features': 10
        }
    ]
}
create_model(spec)
```

This will create a ```torch.nn.Sequential``` object with the specified submodules.
epy-python-kit 0.2.1
A module designed to perform package installations, and verification of install,

# epy_python_kit
A Python package that installs all required packages for estructuraPy (epy) Python code and for _estructúrate_ courses.

This installs the following packages:

* streamlit
* numpy
* pandas
* openpyxl
* lxml
* sympy
* shapely
* vtk
* matplotlib
* plotly
* sectionproperties
* concreteproperties
* PyniteFEA[all]
* pycba
* scipy
* handcalcs
* forallpeople
* pytest
* ipytest
* rich
* tqdm
* papermodels
* xlwings
* black
* jupyterlab
* IPython
* ipywidgets
* ipykernel
* jupyterlab-katex
* jupyterlab-mathjax3 (as an option)
* nbconvert
* pyperclip
* typer
* magicgui[pyside2]
* flit

This is a copy from pfse_starterkit 0.4.4 from Connor Ferster with a few modifications.
csi-analysis 0.5.0
CSI-Cancer analysis pipeline templates.
Requires Python: >=3.11

# csi_analysis: Analytical modules and pipelines for CSI-Cancer

[![PyPI version](https://img.shields.io/pypi/v/csi-analysis)](https://pypi.org/project/csi-analysis/)

This package contains classes and functions for running modular analysis pipelines on
data types commonly used by CSI-Cancer. Currently, this only includes whole-slide
images (immunoflourescent scans). In particular, this package is meant to provide
abstract base classes that can be fit into an then run in a standard pipeline. This will
enable more interchangeability and easier development of new modules, such as for image
segmentation or feature extraction.

While much of the functionality is specific to the CSI-Cancer organization, some of the
functionality and structure may be beneficial for the broader community.
Other packages in the CSI-Cancer organization may depend on this package.

## Structure

Currently, this package contains the main module: `csi_scan_pipeline.py`.
This module contains the abstract base classes for the pipeline, as well as the
`ScanPipeline` class, which is the main class for running the pipeline. This class
contains the `run()` method, which handles parallelization, logging, and passing data
between the module components. 4

## Documentation

For more detailed documentation, open up `docs/index.html` in your browser.

To regenerate the documentation, ensure that you
have [installed the package](#installation) and then run:

```commandline
make_docs
```

## Installation

If you haven't yet, make sure
to [set up an SSH key for GitHub](https://docs.github.com/en/authentication/connecting-to-github-with-ssh/generating-a-new-ssh-key-and-adding-it-to-the-ssh-agent).

1. Activate your `conda` (`conda activate yourenv`) or
   `venv` (`source path/to/your/venv/bin/activate`) environment first.
2. Clone `csi_images` and install:

```commandline
cd ~/path/to/your/repositories
git clone git@github.com:CSI-Cancer/csi_analysis.git
pip install ./csi_analysis
```

Alternatively, you can "editable" install the package, which will allow you to make
changes to the package and have them reflected in your environment without reinstalling:

```commandline
pip install -e ./csi_analysis
```

This will add symbolic links to your `site-packages` directory instead of copying the
package files over.