semvec/pypi-packages huggingface dataset:
numynal 0.1.1
A comprehensive data anlysis library
Requires Python: >=3.10

# numynal

A comprehensive data analysis library

## Modules

- Data preprocessing

  - Missing data
  - Data normalisation and scaling
  - Data augmentation and feature engineering
  - Outlier detection and handling
  - Data imputation

- EDA

  - Statistical summary
  - Correlation and Covariance analysis
  - Interactive web dashboards

- Statstical analysis

  - Distribution
  - Statistical model building
  - Confidence intervals and bootstrap
  - Hypothesis testing
  - Bayesian Methods

- Time Series analysis

  - Decomposition
  - Forecasting methods
  - Anomoly detection

- Autograd

  - Building up on pyAutoGrad
  - Custom optimisation models
  - Autodiff graph visualisation

- ML Models

  - Supervised learning
  - Unsupervised learning
  - Ensemble methods
  - Hyperparameter tuning and model evaluation
  - Model pipelines
  - Transfer learning

- Deep learning

  - NN modules
  - Graph NN
  - Quantisation and pruning
  - pretrained models for common tasks
  - custom architecture support
  - optimisation techniques

- Visualisation

  - Traditional visualisation
  - Model performance visualisation

- Optimisation

  - Parallel processing and GPU support
  - AutoML
  - Model explainability and interpretability support
  - Workflow automation
  - Distributed training

- Performance Monitoring

  - Metrics tracking
  - Real-time monitoring for deployed model
  - Feedback loop

- API support to databases
  - SQL databases (postgres, sqlite, mysql)
  - MongoDB
  - Data streaming support
xotl.tools 3.3.0
Collection of usefull algorithms and other very disparate stuff
Requires Python: >=3.8

``xotl.tools`` is a collection of disparate utilities that does not conform a
framework for anything.  ``xotl.tools`` is essentially -but not exclusively-
an extension to the Python's standard library.

In ``xotl.tools`` you will probably find:

- Tools that must be implemented in the Python Standard Library, but there are
  things that escape from the Guido's scope. ;)

- Components that belong naturally to the "Common Systems Layer" \
  [#continuum]_.

.. [#continuum] http://pubs.opengroup.org/architecture/togaf9-doc/arch/chap39.html#tag_39_04_01


You'll find the documentation in https://merchise-autrement.gitlab.io/xotl.tools/
anchorscad-test-tools 0.1.0
Test helpers for Anchorscad packages.
Requires Python: >=3.10

# anchorscad-test-tools

This package provides a test helper for comparing two iterables based on an
expectation function. It provides more information about the difference
between the two iterables.

The module `anchorscad_lib.test_tools` is the main module in this package.
The `anchorscad_lib` namespace is used by a number of Anchorscad packages.

## Installation

```
pip install anchorscad-test-tools
```

## Usage

```
import unittest
from anchorscad_lib.test_tools import iterable_assert

class TestMyThing(unittest.TestCase):
    def test_almost_same(self):
        iterable_assert(self.assertAlmostEqual, VALUESA, VALUESB, places=3)
```

This is not particularly revolutionary, but it is used by a number of Anchorscad
tests in now different packages which required this to be extracted into a
separate package.
docugenius 0.1.3
Generate docustrings in seconds
Requires Python: >=3.10

# Docugenius
<div>

[Documentation](https://samirsalman.github.io/docugenius/)
</div>
Docugenius is a tool that generates documentation for your python code using LLMs. 
The library provides a simple CLI interface to generate documentation for your python code.



## Installation

```bash
pip install docugenius
```

## Quickstart

Before running docugenius, make sure you exported your OpenAI API key as an environment variable.

```bash
export OPENAI_API_KEY="your-api-key"
```


To generate documentation for your python code, run the following command:

```bash
docugenius path/to/python/code.py
```

The default model used is OpenAI `openai:gpt-4o`, but you can specify a different model using the `--model` flag.

```
docugenius path/to/python/code.py --model openai:gpt-4-mini
```

See the Supported Models section for a list of supported models. [Supported Models](supported-models.md)

If you want to run docugenius on an entire directory, you can pass the directory path as input.

```bash
docugenius path/to/python/directory
```



## CLI Usage

```bash
usage: docugenius [-h] [--model {openai:gpt-4o,openai:gpt-4o-mini}] [--docstring-format {google,numpy,sprinx}] [--skip-raises] [--skip-returns]
                  [--skip-examples] [--output-path OUTPUT_PATH]
                  input_path

positional arguments:
  input_path            The path to the input. You can also pass a directory to process all files in it.

options:
  -h, --help            show this help message and exit
  --model {openai:gpt-4o,openai:gpt-4o-mini}, -m {openai:gpt-4o,openai:gpt-4o-mini}
                        The model to use for generating docstrings.
  --docstring-format {google,numpy,sprinx}, -d {google,numpy,sprinx}
                        The format of the generated docstrings.
  --skip-raises, -r     Whether to include information about exceptions raised by the code.
  --skip-returns, -R    Whether to include information about the return value of the code.
  --skip-examples, -e   Whether to include examples of how to use the code.
  --output-path OUTPUT_PATH, -o OUTPUT_PATH
                        The path to the output file/destination. If not provided, the output will overwrite the input file. If a directory is passed as
                        input, this should be a directory.
```

The output overwrites the input file. If you want to save the output to a different file, you can use the `--output-path` flag.

```bash
docugenius path/to/python/code.py --output path/to/output/file.py
```
truchet-tiling 0.0.32
A truchet tiles generator
Requires Python: >=3.8
Keywords: generative art, pattern, tiling, truchet

# A truchet tiles generator

Creates a truchet pattern as a PNG bitmap.

![](https://raw.githubusercontent.com/con-lit/pattern_generator/refs/heads/main/examples/images/pattern01.png)

## Install

`pip install truchet-tiling`

## Usage

```python
import truchet_tiling.truchet_pattern as tp
from truchet_tiling.themes import RED_FLAMES 

image = tp.generate(
    width=700,
    height=500,
    colors = RED_FLAMES,
    directions='mixed',
    arcs_probability=1,
    stroke_color=0xFFFFFF,
    stroke_width=6
)
```

To try it in Jupyter Notebook:

```python
import truchet_tiling.truchet_pattern as tp

# helper to display bitmap images
def display_image(image_bytes):
  from IPython.display import display, Image as IPImage
  display(IPImage(data=image_bytes.getvalue()))

image = tp.generate(width=800, height=600)
display_image(image)
```

Parameters:  
**width (int)**: Minimal width of the pattern.  
**height (int)**: Minimal height of the pattern.  
**cell_size (int)**: Size of the cell in the pattern.  
**arcs_probability (float)**: Probability of arcs in the pattern. Accepted float values in the range [0, 1].  
**directions (str)**: Direction of the pattern. Accepted values are ['mixed', 'horizontal', 'vertical'].  
**colors (List[int])**: List of colors to use in the pattern. With Null a random color set will be used.  
**stroke_color (int)**: Color of the strokes.  
**stroke_width (int)**: Width of the strokes.