semvec/pypi-packages huggingface dataset:
pyorderly 0.2.1
Reproducible and collaborative reporting
Requires Python: >=3.9

# pyorderly

[![PyPI - Version](https://img.shields.io/pypi/v/pyorderly.svg)](https://pypi.org/project/pyorderly)
[![PyPI - Python Version](https://img.shields.io/pypi/pyversions/pyorderly.svg)](https://pypi.org/project/pyorderly)

-----

**Table of Contents**

- [Installation](#installation)
- [License](#license)

## Installation

```console
pip install pyorderly
```

## Development

Useful hatch commands:

```
hatch shell
hatch run test
hatch run cov
hatch run lint:style
hatch run lint:fmt
```

### Modifying the parser

The outpack query parser is implemented in Rust as part of the
[outpack_server](https://github.com/mrc-ide/outpack_server) repository. When
developing new features in the query parser, they can be tested out in your
development environment of `pyorderly` by installing the parser from your local
checkout:

```
hatch run pip install /path/to/outpack_server
```

## Releasing

- Increment the version number using [the `hatch version` command](https://hatch.pypa.io/latest/version/#updating).
- Commit the changes and create a PR.
- Get the PR approved and merged to main.
- Create a [GitHub release](https://github.com/mrc-ide/pyorderly/releases/new):
  - Set the tag name as `vX.Y.Z`, matching the version reported by hatch.
  - Write some release notes (possibly using the `Generate release notes` button).
  - Publish the release!
- Sit back and relax while the release gets built and published.
- Check that the new version is available on [PyPI](https://pypi.org/project/pyorderly/#history).

## License

`pyorderly` is distributed under the terms of the [MIT](https://spdx.org/licenses/MIT.html) license.
nececv 0.2.6
NECECV – LLMs, Computer Vision, and Enterprise Semantic Cache
Requires Python: >=3.6

NECECV

NECECV is an advanced AI systems platform that combines:

Generative Language Models

Computer Vision Intelligence

Enterprise-grade Semantic Caching Infrastructure

NECECV is designed to act as a foundation layer for building high-performance AI agents, copilots, and automation systems.

Features
1. Generative Universe Engine

A hierarchical generative language model inspired by planetary systems, enabling layered semantic reasoning and structured text generation.

nececv.planet_generative_model

2. Computer Vision – PreEdge

A hybrid deep-learning + epsilon-learning edge detection system built on top of VGG16, Canny, and Sobel filtering.

Supports:

Object classification

Edge density estimation

Adaptive edge detection

Visualization

nececv.obj_det.PreEdge

3. Enterprise Semantic Cache

A RAM-bounded, vector-aware cache layer for LLMs, APIs, and AI agents.

Supports:

Semantic similarity matching

LRU eviction

FTPL (learning-based eviction)

Real RAM budgeting

nececv.semantic_cache


This allows NECECV to behave like real AI infrastructure used in production systems.

Installation
pip install nececv

1️⃣ Generative Universe (LLM)
from nececv.planet_generative_model import llm_genUniverse

model = llm_genUniverse()
print(model.generate("AI will change the world"))

2️⃣ Computer Vision (PreEdge)
from nececv import PreEdge

detector = PreEdge()

predictions = detector.detect_object_probability("image.jpg")
edges = detector.generate_edge_image("image.jpg", predictions, epsilon=0.1, iterations=10)

detector.display_results("image.jpg", predictions=predictions, edge_image="Canny")

3️⃣ Semantic Cache (LLM Infra)
import nececv

cache = nececv.LRUSemanticCache(max_ram_mb=512)

def llm(query):
    return "LLM response for: " + query

router = nececv.SemanticRouter(cache, llm)

embedding = embed("reset password")   # user-provided embedding
router.query("reset password", embedding)


The cache automatically:

Finds semantic matches

Reuses previous outputs

Evicts data when RAM limit is reached