semvec/pypi-packages huggingface dataset:
zenofai 0.1.1
The Zen of GenAI, printed on import
Requires Python: >=3.8
Keywords: AI, Python, Zen, package

# zenofai

### The Guiding Philosophy for the Age of GenAI

In the age of AI, writing Python is no longer just about what you type—it's about what you ask, verify, and improve. The `zenofai` package provides a guiding philosophy for this new era of collaboration.

By simply importing this package, you are reminded of the principles that foster thoughtful and effective human-AI partnerships, ensuring that your code remains clear, correct, and intentional.

---

### The Zen of GenAI, by Anuj Sadani

Just as the original Zen of Python provides a timeless guide for developers, the Zen of GenAI offers principles for the modern AI-assisted workflow.

```python
>>> import zenofai
````

The principles are:

1.  **Clarity of intent is better than volume of output.**
2.  **Prompt with purpose**—lazy prompting leads to lazy outcome.
3.  **Verify relentlessly**—AI can hallucinate; your tests should not.
4.  **Human judgment is irreplaceable.**
5.  **Transparency is a powerful ally.**
6.  **Readability counts, especially in generated code.**
7.  **Refactor good ideas rather than reinventing vague ones.**
8.  **Reuse wisdom, not just code.**
9.  **Every suggestion deserves scrutiny**—trust is earned, even by models.
10. **Errors should never be silently ignored** unless explicitly understood and accepted.
11. **If code is hard for a human to explain, it’s a bad idea.**
12. **If code is easy for a human to explain, it may be a good idea.**
13. **In deterministic tasks, keep the temperature zero.**
14. **Let code be the documentation.**
15. **Bias compounds**—challenge familiar patterns.
16. **The best output is the one you truly understand.**

-----

### Installation

```bash
pip install zenofai
```

### Usage

  - **Concise version:**

    ```python
    >>> import zenofai
    # Output: The Zen of GenAI, by Anuj Sadani
    # 1. Clarity of intent is better than volume of output.
    # ...and so on.
    ```

  - **Verbose version:**

    ```python
    >>> from zenofai import verbose
    # Output: (The Zen with more detailed explanations)
    ```

-----

### LICENSE

[MIT](https://opensource.org/licenses/MIT)
edc-appconfig 1.0.3
Custom AppConfig for main app of clinicedc/edc projects
Requires Python: <3.14,>=3.12
Keywords: AppConfig, Edc, clinical, clinicedc, django, trials

|pypi| |actions| |codecov| |downloads| |maintainability| |black|

edc-appconfig
-------------

Last app in ``INSTALLED_APPS`` for ``clinicedc`` projects::

    # settings.py

    INSTALLED_APPS = [
        ...
        "edc_appconfig.apps.AppConfig"
        ]



.. |pypi| image:: https://img.shields.io/pypi/v/edc-appconfig.svg
    :target: https://pypi.python.org/pypi/edc-appconfig

.. |actions| image:: https://github.com/clinicedc/edc-appconfig/actions/workflows/build.yml/badge.svg
  :target: https://github.com/clinicedc/edc-appconfig/actions/workflows/build.yml

.. |codecov| image:: https://codecov.io/gh/clinicedc/edc-appconfig/branch/develop/graph/badge.svg
  :target: https://codecov.io/gh/clinicedc/edc-appconfig

.. |downloads| image:: https://pepy.tech/badge/edc-appconfig
   :target: https://pepy.tech/project/edc-appconfig

.. |maintainability| image:: https://api.codeclimate.com/v1/badges/434041d6c2f424ce5fd7/maintainability
   :target: https://codeclimate.com/github/clinicedc/edc-appconfig/maintainability
   :alt: Maintainability

.. |black| image:: https://img.shields.io/badge/code%20style-black-000000.svg
   :target: https://github.com/ambv/black
   :alt: Code Style
rohan-pristine-sbert-v1 0.1.0
Hybrid SBERT embeddings using all-MiniLM-L6-v2 and all-mpnet-base-v2.
Requires Python: >=3.7

# Rohan Pristine SBERT v1

**rohan-pristine-sbert-v1** is a Python package that combines two powerful Sentence Transformers:
- `all-MiniLM-L6-v2`
- `all-mpnet-base-v2`

This hybrid approach produces sentence embeddings by averaging outputs from both models.

## Installation

```bash
pip install rohan-pristine-sbert-v1
fractalplots 0.1.2
Generate and visualize fractal patterns like Mandelbrot, Julia, Koch, Sierpinski, and L-Systems.
Requires Python: >=3.7
Keywords: fractal, math, visualization, mandelbrot, julia, koch, sierpinski, l-system



# fractalplots 🧩

**fractalplots** is a Python package for generating and visualizing fractal patterns like the Mandelbrot set, Julia set, Koch snowflake, Sierpinski triangle, and L-system fractals. Each fractal can be generated with a single function call.

---

## 📦 Installation

Install from PyPI (after publishing):

```bash
pip install fractalplots
````

Or install from source:

```bash
git clone https://github.com/bhavykhatri/fractalplots.git
cd fractalplots
pip install -e .
```

---

## 🌀 Fractal Patterns

### 🟡 Mandelbrot Set

The Mandelbrot set is generated by checking which complex numbers remain bounded under a recurrence formula. It produces the iconic cardioid shape with infinite detail.

![Mandelbrot](https://raw.githubusercontent.com/bhavykhatri/fractalplots/main/assets/mandelbrot.png)

---

### 🟣 Julia Set

Julia sets are variations of the Mandelbrot fractal, defined using a fixed complex constant. Different constants produce different fractal "personalities".

![Julia](https://raw.githubusercontent.com/bhavykhatri/fractalplots/main/assets/julia.png)

---

### ❄️ Koch Snowflake

The Koch snowflake begins as an equilateral triangle. Each side is recursively replaced with a spike pattern, creating a snowflake boundary.

![Koch](https://raw.githubusercontent.com/bhavykhatri/fractalplots/main/assets/koch.png)

---

### 🔺 Sierpinski Triangle

A classic example of a recursive fractal made by repeatedly removing the center of a triangle. The pattern reveals a triangular lattice structure.

![Sierpinski](https://raw.githubusercontent.com/bhavykhatri/fractalplots/main/assets/sierpinski.png)

---

### 🌿 L-System Fractal

L-Systems (Lindenmayer Systems) use rewriting rules to simulate fractal growth like that of plants, corals, and trees.

![L-System](https://raw.githubusercontent.com/bhavykhatri/fractalplots/main/assets/lsystem.png)

---

## ✏️ Example Usage

Here’s how to generate and save a Mandelbrot image:

```python
from fractalplots import generate_mandelbrot, plot_mandelbrot

div_time = generate_mandelbrot()
plot_mandelbrot(div_time, save_path="mandelbrot.png", show=False)
```

Every fractal module provides two functions:

* `generate_*`: Computes data (e.g., image matrix or point list)
* `plot_*`: Renders or saves the fractal image

---

## 📁 Folder Structure

```
fractalplots/
├── fractalplots/
│   ├── mandelbrot.py
│   ├── julia.py
│   ├── koch.py
│   ├── sierpinski.py
│   ├── lsystem.py
│   └── __init__.py
├── examples/
├── tests/
├── assets/
│   └── *.png
├── README.md
├── LICENSE
└── pyproject.toml
```

---

## 🧪 Run Tests

To verify everything works:

```bash
pytest tests/
```

---

## 🤝 Contributing

Fractals are fun and there's room for more! Contributions are welcome — add new fractal types, optimize existing ones, or improve rendering. Fork the repo and open a pull request.

---

## 📄 License

MIT License © 2025 Bhavy Khatri
algebrix 1.0.1
Linear algebra on Python — вектора, матрицы, разложения
Requires Python: >=3.10

# Algebrix
--- 

**Algebrix** is a simple and powerful library for working with vectors and matrices. Supports basic linear algebra operations, including:

* Addition, subtraction, scalar and matrix multiplication

* Normalization of vectors, calculation of angle, projections

* Transpose, inverse matrix, reshape

* And much more

## Installing
```bash
pip install algebrix
```

## Usage examples
```python
from algebrix import Matrix, Vector

# Векторы
v1 = Vector([1, 2, 3])
v2 = Vector([4, 5, 6])

print(v1 + v2)             # Vector([5, 7, 9])
print(v1.dot(v2))          # 32
print(v1.norm())           # 3.741...
print(v1.project_onto(v2)) # Проекция v1 на v2

# Матрицы
m1 = Matrix([[1, 2], [3, 4]])
m2 = Matrix([[5, 6], [7, 8]])

print(m1 + m2)             # Matrix([[6, 8], [10, 12]])
print(m1 * m2)             # Matrix([[19, 22], [43, 50]])
print(m1.T())              # Matrix([[1, 3], [2, 4]])
print(m1.inverse())        # Matrix([[-2.0, 1.0], [1.5, -0.5]])

```

## 🧠 Features
### 🟦 Vector Class
Implements:

* __add__, __sub__, __mul__, __rmul__

* dot(other): dot product

* norm(): Euclidean norm

* normalize(): unit vector

* project_onto(other): vector projection

* angle_with(other): angle between vectors (in radians)

### 🟩 Matrix Class
Implements:

* __add__, __sub__, __mul__, __rmul__

* T(): transpose

* inverse(): matrix inverse

* shape(): returns (rows, cols)

* reshape((new_rows, new_cols)): reshapes the matrix

🛠️ Requirements
* Python 3.10+

* Only depends on the built-in math module (no third-party dependencies)