semvec/pypi-packages huggingface dataset:
humemai-research 2.5.6.post2
A Machine With Human-Like Memory
Requires Python: >=3.10

# HumemAI Research

HumemAI Research explores **human-like memory systems** for AI — combining **episodic** (experience-based) and **semantic** (knowledge-based) memory models.

We study how machines can store, retrieve, and reason over structured memory graphs built from text, tables, and user interactions.

## Installation

```bash
pip install humemai-research
```

## Usage

```python
from humemai_research.rdflib import Humemai
# or
from humemai_research.janusgraph import Humemai
```

## Research Areas

- **Episodic Memory:** Representing conversations and experiences as temporal property graphs.  
- **Semantic Memory:** Integrating user-provided or external data (e.g. Wikidata, Wikipedia) into graph, table, and vector formats.  
- **Memory Management:** Learning what to remember, summarize, or forget across time.  
- **Graph-Based Reasoning:** Querying and updating symbolic–neural hybrid memories.  
- **Reinforcement Learning & Knowledge Graphs:** Using RL to induce hierarchies and explore knowledge structures.
vt-err-hndlr 0.0.0.dev6
Common errors and warnings for Vaastav Technologies (vt) projects.
Requires Python: >=3.12
Keywords: error, error-handling, error-handler, warning, warn

# vt-err-hndlr

![PyPI - Python Version](https://img.shields.io/pypi/pyversions/vt-err-hndlr)
![PyPI - Types](https://img.shields.io/pypi/types/vt-err-hndlr)
![GitHub License](https://img.shields.io/github/license/Vaastav-Technologies/py-err-hndlr)
[![🔧 test](https://github.com/Vaastav-Technologies/py-err-hndlr/actions/workflows/test.yml/badge.svg)](https://github.com/Vaastav-Technologies/py-err-hndlr/actions/workflows/test.yml)
[![💡 typecheck](https://github.com/Vaastav-Technologies/py-err-hndlr/actions/workflows/typecheck.yml/badge.svg)](https://github.com/Vaastav-Technologies/py-err-hndlr/actions/workflows/typecheck.yml)
[![🛠️ lint](https://github.com/Vaastav-Technologies/py-err-hndlr/actions/workflows/lint.yml/badge.svg)](https://github.com/Vaastav-Technologies/py-err-hndlr/actions/workflows/lint.yml)
[![📊 coverage](https://codecov.io/gh/Vaastav-Technologies/py-err-hndlr/branch/main/graph/badge.svg)](https://codecov.io/gh/Vaastav-Technologies/py-err-hndlr)
[![📤 Upload Python Package](https://github.com/Vaastav-Technologies/py-err-hndlr/actions/workflows/python-publish.yml/badge.svg)](https://github.com/Vaastav-Technologies/py-err-hndlr/actions/workflows/python-publish.yml)
![PyPI - Version](https://img.shields.io/pypi/v/vt-err-hndlr)

---

Fully typed collection of common python interfaces and handers for errors and warnings.
ikemurami 0.0.2
Defense against dependency confusion attacks
Requires Python: >=3.9

# pypi-package

Defense against dependency confusion attacks

PyPI: https://pypi.org/project/ikemurami

## Install and run

```
python3 -m venv .venv
source .venv/bin/activate
python -m pip install "."
python -B examples/main.py
```

## Build & distribute

- Docs: https://packaging.python.org/en/latest/tutorials/packaging-projects/

- Build:

```
python -m pip install --upgrade build
python -m build
```

- Distribute:

```
python -m pip install --upgrade twine
python -m twine upload --repository pypi dist/*
```
snap-pslg 0.5.0
simplify a pslg with iterated snap rounding
Requires Python: >=3.10

t# snap_pslg

Refine a [planar straight-line graph](https://en.wikipedia.org/wiki/Planar_straight-line_graph) with [iterated snap rounding](https://citeseerx.ist.psu.edu/viewdoc/summary?doi=10.1.1.23.220). No numpy dependency.

* floor all points to integer coordinates
* eliminate edge intersections and t-junctions
* if allowed to converge, no point will be within .5 units of an edge. You can remove this constraint entirely, maintaing more of the input shape at the cost of near t-junctions, by setting max_iterations to 0.

This will slightly distort the pslg, but the result will be ready for triangulation and other algorithms.

## install
~~~
pip install snap_pslg
~~~

## signature
~~~python
Vec2 = Annotated[Iterable[float], "2D vector"]

def snap_round_pslg(
    points: Iterable[Vec2], edges: Iterable[tuple[int, int]], max_iterations: int = 100
) -> tuple[list[IntPoint], list[tuple[int, int]]]:
    """Perform one iteration of snap rounding.

    :param points: A list of 2D points
    :param edges: A list of edges, each a pair of indices into points
    :param max_iterations: optionally limit number of iterations to perform. By
        default, will try 100 iterations to reach convergence.
    :return: A list of 2D points, a list of edges, each a pair of indices into points

    Some of the points may not have indices. That is fine.
    """
~~~

## usage

~~~python
from snap_pslg import snap_round_pslg

points = [(0, 0), (3, 0), (3, 3), (0, 3), (5, 5)]
edges = [(0, 2), (1, 3)]

# You might have noticed that point (5, 5) was never used. This is fine. It
# will be retained as a point and any line segments that pass very close to it
# will be routed through it.

new_points, new_segments = snap_round_pslg(points, edges)

new_points  # [(0, 0), (5, 5), (3, 3), (2, 2), (0, 3), (3, 0)]
new_edges  # [(0, 3), (4, 3), (3, 2), (3, 5)]

# a new point, (3, 3) has been added at the segment intersection
# each segment is broken into two pieces
~~~