vector-crypt 0.1.0__tar.gz

vector_crypt-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Sagu4ka
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

vector_crypt-0.1.0/PKG-INFO

@@ -0,0 +1,116 @@
+Metadata-Version: 2.4
+Name: vector_crypt
+Version: 0.1.0
+Summary: A toy cryptographic library encoding data as applied vector sets.
+Author-email: Sagu4ka <sagu4ka@gmail.com>
+License: MIT
+Keywords: cryptography,vector,encoding,one-time-pad
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# Applied-Vector Crypto (`vector_crypt`)
+
+A lightweight Python library demonstrating a **novel cryptographic
+principle**: represent both plaintext and keys as _sets of applied vectors_
+and perform encryption simply by vector addition.  The package is intended as
+an educational toy, a research starting point, or a playful experiment rather
+than a drop-in replacement for real-world ciphers.
+
+## 🚀 Основная идея
+
+Каждый байт (или символ, блок) сообщения кодируется как
+**`AppliedVector`** — отрезок с фиксированным началом и направлением.  Ключ
+тоже является набором таких векторов.  Шифрование сводится к поэлементному
+сложению двух наборов (похожим на операцию `XOR` для чисел), а расшифровка –
+к вычитанию.
+
+*В отличие от большинства алгоритмов, здесь информация представлена геометрически,
+что даёт визуализацию, естественное расширение на многомерность и простой
+потоковый интерфейс.*
+
+### Почему это уникально?
+
+- **Геометрическое представление.**  Традиционные симметричные схемы оперируют
+  на битах и байтах.  Мы работаем с векторами, что позволяет легко вводить
+  масштабирование, вращения, линейные преобразования и работать в произвольных
+  пространствах (включая конечные поля).
+
+- **Простота.**  Всего пара строк кода даёт шифрование/дешифровку.  Нет S‑боксов,
+  нет ключевого расписания, только алгебра над векторами.
+
+- **Потоковая обработка.**  Код поддерживает генераторы, чтение/запись файлов
+  по кускам и пакетные операции, что пригодится для больших данных.
+
+- **Проверяемость.**  Отображение вектор‑множества на экран, графы, SVG…
+  Приятно для обучения и визуальных демо.
+
+## 🔍 Схожие идеи в криптографии
+
+- **One‑time pad / Vernam cipher.**  Байт сообщения прибавляется к байту ключа
+  по модулю 2⁸; наша операция аналогична, но мы «вырастаем» в векторное
+  пространство и сохраняем абсолютную информацию в промежуточном виде (можно
+  наложить дополнительные операции).
+
+- **Кодировка векторов в стойкие каналы.**  В теории информации часто
+  рассматривают передаваемые сигналы как точки в \\Rⁿ; в этом смысле наше
+  шифрование — частный случай линейного кодирования.
+
+- **Графовые шифры.**  В гомоморфных системах используются линейные операции;
+  наш механизм легко расширяется до гомоморфизма над векторным пространством.
+
+Однако: мы не претендуем на криптостойкость, а скорее демонстрируем новый
+формальный подход.  Внедрить в реальную систему потребует серьёзного
+криптоанализа и, вероятно, модификаций (например, работа в конечных полях,
+нелинейные слои и т. д.).
+
+## 🧩 Структура проекта
+
+```
+vector_crypt/        # репозиторий
+├── vector_crypt/     # собственно пакет Python
+│   ├── __init__.py
+│   ├── classes.py
+│   ├── endecode.py
+│   ├── keygen.py
+│   └── vector_codec.py
+├── tests/            # простые тесты (пока минимум)
+├── README.md         # вы читаете
+├── LICENSE           # MIT
+└── pyproject.toml    # сборка/метаданные
+```
+
+## ⚙️ Установка и использование
+
+```bash
+pip install vector_crypt
+```
+
+```python
+from vector_crypt import encrypt_text, decrypt_text, key_for_data
+
+key = key_for_data(b"secret message")
+cipher = encrypt_text("hello", key)
+print(decrypt_text(cipher, key))  # hello
+```
+
+Для потокового шифрования используйте `encrypt_bytes_stream` вместе с
+`generate_random_key_stream`.
+
+## 📝 Где использовать
+
+Библиотека подходит для:
+
+* учебных примеров и лекций по основам криптографии;
+* прототипирования альтернативных представлений данных (векторов вместо
+  скаляров);
+* демонстраций визуализации шифрования в 2D/3D;
+* утилит, где требуется совместное хранение геометрической информации и
+  шифрования (например, защитить набор координат).
+
+Не рекомендуется применять `vector_crypt` для защиты реальных данных без
+дополнительного анализа.

vector_crypt-0.1.0/README.md

@@ -0,0 +1,101 @@
+# Applied-Vector Crypto (`vector_crypt`)
+
+A lightweight Python library demonstrating a **novel cryptographic
+principle**: represent both plaintext and keys as _sets of applied vectors_
+and perform encryption simply by vector addition.  The package is intended as
+an educational toy, a research starting point, or a playful experiment rather
+than a drop-in replacement for real-world ciphers.
+
+## 🚀 Основная идея
+
+Каждый байт (или символ, блок) сообщения кодируется как
+**`AppliedVector`** — отрезок с фиксированным началом и направлением.  Ключ
+тоже является набором таких векторов.  Шифрование сводится к поэлементному
+сложению двух наборов (похожим на операцию `XOR` для чисел), а расшифровка –
+к вычитанию.
+
+*В отличие от большинства алгоритмов, здесь информация представлена геометрически,
+что даёт визуализацию, естественное расширение на многомерность и простой
+потоковый интерфейс.*
+
+### Почему это уникально?
+
+- **Геометрическое представление.**  Традиционные симметричные схемы оперируют
+  на битах и байтах.  Мы работаем с векторами, что позволяет легко вводить
+  масштабирование, вращения, линейные преобразования и работать в произвольных
+  пространствах (включая конечные поля).
+
+- **Простота.**  Всего пара строк кода даёт шифрование/дешифровку.  Нет S‑боксов,
+  нет ключевого расписания, только алгебра над векторами.
+
+- **Потоковая обработка.**  Код поддерживает генераторы, чтение/запись файлов
+  по кускам и пакетные операции, что пригодится для больших данных.
+
+- **Проверяемость.**  Отображение вектор‑множества на экран, графы, SVG…
+  Приятно для обучения и визуальных демо.
+
+## 🔍 Схожие идеи в криптографии
+
+- **One‑time pad / Vernam cipher.**  Байт сообщения прибавляется к байту ключа
+  по модулю 2⁸; наша операция аналогична, но мы «вырастаем» в векторное
+  пространство и сохраняем абсолютную информацию в промежуточном виде (можно
+  наложить дополнительные операции).
+
+- **Кодировка векторов в стойкие каналы.**  В теории информации часто
+  рассматривают передаваемые сигналы как точки в \\Rⁿ; в этом смысле наше
+  шифрование — частный случай линейного кодирования.
+
+- **Графовые шифры.**  В гомоморфных системах используются линейные операции;
+  наш механизм легко расширяется до гомоморфизма над векторным пространством.
+
+Однако: мы не претендуем на криптостойкость, а скорее демонстрируем новый
+формальный подход.  Внедрить в реальную систему потребует серьёзного
+криптоанализа и, вероятно, модификаций (например, работа в конечных полях,
+нелинейные слои и т. д.).
+
+## 🧩 Структура проекта
+
+```
+vector_crypt/        # репозиторий
+├── vector_crypt/     # собственно пакет Python
+│   ├── __init__.py
+│   ├── classes.py
+│   ├── endecode.py
+│   ├── keygen.py
+│   └── vector_codec.py
+├── tests/            # простые тесты (пока минимум)
+├── README.md         # вы читаете
+├── LICENSE           # MIT
+└── pyproject.toml    # сборка/метаданные
+```
+
+## ⚙️ Установка и использование
+
+```bash
+pip install vector_crypt
+```
+
+```python
+from vector_crypt import encrypt_text, decrypt_text, key_for_data
+
+key = key_for_data(b"secret message")
+cipher = encrypt_text("hello", key)
+print(decrypt_text(cipher, key))  # hello
+```
+
+Для потокового шифрования используйте `encrypt_bytes_stream` вместе с
+`generate_random_key_stream`.
+
+## 📝 Где использовать
+
+Библиотека подходит для:
+
+* учебных примеров и лекций по основам криптографии;
+* прототипирования альтернативных представлений данных (векторов вместо
+  скаляров);
+* демонстраций визуализации шифрования в 2D/3D;
+* утилит, где требуется совместное хранение геометрической информации и
+  шифрования (например, защитить набор координат).
+
+Не рекомендуется применять `vector_crypt` для защиты реальных данных без
+дополнительного анализа.

vector_crypt-0.1.0/pyproject.toml

@@ -0,0 +1,27 @@
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "vector_crypt"
+version = "0.1.0"
+description = "A toy cryptographic library encoding data as applied vector sets."
+authors = [
+    {name = "Sagu4ka", email = "sagu4ka@gmail.com"},
+]
+readme = "README.md"
+license = {text = "MIT"}
+requires-python = ">=3.8"
+keywords = ["cryptography", "vector", "encoding", "one-time-pad"]
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+]
+
+# no external dependencies for now
+dependencies = []
+
+[tool.setuptools.packages.find]
+where = ["."]
+include = ["vector_crypt*"]

vector_crypt-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

vector_crypt-0.1.0/tests/test_basic.py

@@ -0,0 +1,27 @@
+import pytest
+
+from vector_crypt import (
+    Point,
+    encrypt,
+    decrypt,
+    bytes_to_vectors,
+    vectors_to_bytes,
+    generate_random_key,
+    encrypt_bytes_stream,
+    generate_random_key_stream,
+)
+
+
+def test_roundtrip_bytes():
+    data = b"hello"
+    key = generate_random_key(len(data))
+    vec = bytes_to_vectors(data)
+    cipher = encrypt(vec, key)
+    assert decrypt(cipher, key) == vec
+
+
+def test_stream_bytes():
+    data = b"streamy"
+    key_stream = generate_random_key_stream(len(data))
+    enc = list(encrypt_bytes_stream(data, key_stream))
+    assert len(enc) == len(data)

vector_crypt-0.1.0/vector_crypt/__init__.py

@@ -0,0 +1,85 @@
+"""Top-level package for the applied-vector cryptography library.
+
+The package is intentionally small and re-exports most of the user-facing
+symbols from its submodules.  Importing :mod:`vector_crypt` gives you access to
+all the functionality described in the README.
+"""
+
+from __future__ import annotations
+
+# re-export core data classes
+from .classes import (
+    Point,
+    Vector,
+    AppliedVector,
+    AppliedVectorSet,
+)
+
+# encryption / decryption helpers
+from .endecode import (
+    encrypt,
+    decrypt,
+    encrypt_bytes,
+    decrypt_bytes,
+    encrypt_text,
+    decrypt_text,
+    encrypt_sequence,
+    decrypt_sequence,
+    encrypt_bytes_stream,
+    decrypt_bytes_stream,
+)
+
+# codec utilities
+from .vector_codec import (
+    bytes_to_vectors,
+    vectors_to_bytes,
+    text_to_vectors,
+    vectors_to_text,
+    bytes_to_vectors_stream,
+    vectors_to_bytes_stream,
+    file_to_vectors,
+    vectors_to_file,
+)
+
+# key generation helpers
+from .keygen import (
+    generate_random_key,
+    key_for_data,
+    generate_random_key_stream,
+    generate_batch_keys,
+    key_stream_for_data,
+)
+
+__all__ = [
+    # core
+    "Point",
+    "Vector",
+    "AppliedVector",
+    "AppliedVectorSet",
+    # encryption
+    "encrypt",
+    "decrypt",
+    "encrypt_bytes",
+    "decrypt_bytes",
+    "encrypt_text",
+    "decrypt_text",
+    "encrypt_sequence",
+    "decrypt_sequence",
+    "encrypt_bytes_stream",
+    "decrypt_bytes_stream",
+    # codecs
+    "bytes_to_vectors",
+    "vectors_to_bytes",
+    "text_to_vectors",
+    "vectors_to_text",
+    "bytes_to_vectors_stream",
+    "vectors_to_bytes_stream",
+    "file_to_vectors",
+    "vectors_to_file",
+    # keygen
+    "generate_random_key",
+    "key_for_data",
+    "generate_random_key_stream",
+    "generate_batch_keys",
+    "key_stream_for_data",
+]

vector_crypt-0.1.0/vector_crypt/classes.py

@@ -0,0 +1,154 @@
+from math import sqrt
+from typing import Iterable
+
+class Point:
+    """Class of a point in space"""
+    def __init__(self, x: float, y: float):
+        self.x = x
+        self.y = y
+
+    def __repr__(self):
+        return f"Point({self.x}, {self.y})"
+
+    def __eq__(self, other):
+        if not isinstance(other, Point):
+            return NotImplemented
+        return self.x == other.x and self.y == other.y
+
+class Vector:
+    """A vector class with no fixed location. It has only an endpoint, as if it were located at coordinates 0, 0.
+       More accurately, it represents the components (dx, dy) of the vector."""
+    def __init__(self, dx: float, dy: float):
+        self.dx = dx
+        self.dy = dy
+    
+    @classmethod
+    def from_points(cls, start_point: Point, end_point: Point):
+        """Creates a Vector from two points."""
+        dx = end_point.x - start_point.x
+        dy = end_point.y - start_point.y
+        return cls(dx, dy)
+
+    def get_length(self) -> float:
+        return sqrt(self.dx**2 + self.dy**2)
+
+    def __repr__(self):
+        return f"Vector(dx={self.dx}, dy={self.dy})"
+
+    def __add__(self, other):
+        if not isinstance(other, Vector):
+            return NotImplemented
+        return Vector(self.dx + other.dx, self.dy + other.dy)
+
+    def __sub__(self, other):
+        if not isinstance(other, Vector):
+            return NotImplemented
+        return Vector(self.dx - other.dx, self.dy - other.dy)
+
+    def __mul__(self, scalar: float):
+        return Vector(self.dx * scalar, self.dy * scalar)
+
+    def __rmul__(self, scalar: float):
+        return self.__mul__(scalar)
+
+    def dot_product(self, other) -> float:
+        if not isinstance(other, Vector):
+            raise TypeError("Can only perform dot product with another Vector.")
+        return self.dx * other.dx + self.dy * other.dy
+
+class AppliedVector:
+    """
+    Represents a vector applied to a specific starting point.
+    It has:
+    - Direction (like a Vector)
+    - Length (like a line segment)
+    - Fixed coordinates (like a Point, specifically its start_point)
+    """
+    def __init__(self, start_point: Point, end_point: Point):
+        self.start_point = start_point
+        self.end_point = end_point
+        self._free_vector = Vector.from_points(start_point, end_point)
+
+    @property
+    def direction_vector(self) -> Vector:
+        return self._free_vector
+
+    def get_length(self) -> float:
+        return self._free_vector.get_length()
+
+    def __repr__(self):
+        return f"AppliedVector(start={self.start_point}, end={self.end_point})"
+
+    def __eq__(self, other):
+        if not isinstance(other, AppliedVector):
+            return NotImplemented
+        return self.start_point == other.start_point and self.end_point == other.end_point
+
+    def __add__(self, other):
+        if not isinstance(other, AppliedVector):
+            return NotImplemented
+        
+        result_free_vector = self.direction_vector + other.direction_vector
+        
+        new_end_x = self.start_point.x + result_free_vector.dx
+        new_end_y = self.start_point.y + result_free_vector.dy
+        return AppliedVector(self.start_point, Point(new_end_x, new_end_y))
+
+    def __sub__(self, other):
+        if not isinstance(other, AppliedVector):
+            return NotImplemented
+        
+        result_free_vector = self.direction_vector - other.direction_vector
+        
+        new_end_x = self.start_point.x + result_free_vector.dx
+        new_end_y = self.start_point.y + result_free_vector.dy
+        return AppliedVector(self.start_point, Point(new_end_x, new_end_y))
+    
+    def __mul__(self, scalar: float):
+        scaled_free_vector = self.direction_vector * scalar
+        new_end_x = self.start_point.x + scaled_free_vector.dx
+        new_end_y = self.start_point.y + scaled_free_vector.dy
+        return AppliedVector(self.start_point, Point(new_end_x, new_end_y))
+
+    def __rmul__(self, scalar: float):
+        return self.__mul__(scalar)
+
+class AppliedVectorSet:
+    """A set of applied vectors that support element-wise operations."""
+    def __init__(self, vectors: Iterable[AppliedVector] = (), origin: Point | None = None):
+        self.vectors = list(vectors)
+        self.origin = origin
+
+    def __len__(self):
+        return len(self.vectors)
+
+    def __iter__(self):
+        return iter(self.vectors)
+
+    def __repr__(self):
+        return f"<AppliedVectorSet {self.vectors!r}>"
+
+    def __eq__(self, other: "AppliedVectorSet"):
+        if not isinstance(other, AppliedVectorSet):
+            return NotImplemented
+        return self.origin == other.origin and self.vectors == other.vectors
+
+    def __add__(self, other: "AppliedVectorSet"):
+        if len(self) != len(other):
+            raise ValueError("The sizes of the sets must match!")
+        return AppliedVectorSet(
+            (a + b for a, b in zip(self.vectors, other.vectors)),
+            origin=self.origin or other.origin,
+        )
+
+    def __sub__(self, other: "AppliedVectorSet"):
+        if len(self) != len(other):
+            raise ValueError("The sizes of the sets must match!")
+        return AppliedVectorSet(
+            (a - b for a, b in zip(self.vectors, other.vectors)),
+            origin=self.origin or other.origin,
+        )
+
+    def scalar_mul(self, scalar: float):
+        return AppliedVectorSet((v * scalar for v in self.vectors),
+                                origin=self.origin)

vector_crypt-0.1.0/vector_crypt/endecode.py

@@ -0,0 +1,95 @@
+from __future__ import annotations
+
+from typing import Iterable, Iterator
+
+from .classes import AppliedVectorSet, AppliedVector, Point
+from .vector_codec import (
+    bytes_to_vectors,
+    vectors_to_bytes,
+    text_to_vectors,
+    vectors_to_text,
+)
+from .keygen import key_for_data
+
+
+def encrypt(plaintext: AppliedVectorSet,
+            key: AppliedVectorSet) -> AppliedVectorSet:
+    return plaintext + key
+
+def decrypt(ciphertext: AppliedVectorSet,
+            key: AppliedVectorSet) -> AppliedVectorSet:
+    return ciphertext - key
+
+
+# high-level helpers ----------------------------------------------------------
+
+def encrypt_bytes(data: bytes, key: AppliedVectorSet) -> AppliedVectorSet:
+    """Encrypt raw data.  ``key`` must be at least as long as ``data``."""
+    pt = bytes_to_vectors(data)
+    return encrypt(pt, key)
+
+
+def decrypt_bytes(cipher: AppliedVectorSet, key: AppliedVectorSet) -> bytes:
+    """Decrypt to raw bytes.  ``cipher`` and ``key`` should have equal length."""
+    pt = decrypt(cipher, key)
+    return vectors_to_bytes(pt)
+
+
+def encrypt_text(text: str, key: AppliedVectorSet, encoding: str = "utf-8") -> AppliedVectorSet:
+    """Convenience: encode and encrypt a string."""
+    return encrypt(text_to_vectors(text, encoding=encoding), key)
+
+
+def decrypt_text(cipher: AppliedVectorSet, key: AppliedVectorSet, encoding: str = "utf-8") -> str:
+    """Decrypt and decode to text."""
+    return vectors_to_text(decrypt(cipher, key), encoding=encoding)
+
+
+# batch / streaming helpers ---------------------------------------------------
+
+def encrypt_sequence(
+    plaintexts: Iterable[AppliedVectorSet],
+    keys: Iterable[AppliedVectorSet],
+) -> list[AppliedVectorSet]:
+    """Encrypt many plaintext vector sets with corresponding keys.
+
+    Both iterables are consumed in lockstep; lengths must match.
+    """
+    return [encrypt(p, k) for p, k in zip(plaintexts, keys)]
+
+
+def decrypt_sequence(
+    ciphertexts: Iterable[AppliedVectorSet],
+    keys: Iterable[AppliedVectorSet],
+) -> list[AppliedVectorSet]:
+    """Decrypt many ciphertexts with the provided keys."""
+    return [decrypt(c, k) for c, k in zip(ciphertexts, keys)]
+
+
+def encrypt_bytes_stream(
+    data: Iterable[int],
+    key_stream: Iterable[AppliedVector],
+    origin: Point | None = None,
+) -> Iterator[AppliedVector]:
+    """Stream-encrypt a byte sequence against a stream of key vectors.
+
+    ``data`` yields byte values; ``key_stream`` yields pre-generated random
+    ``AppliedVector`` objects.  The resulting stream produces encrypted vectors
+    that can be consumed without buffering the whole message.
+    """
+    if origin is None:
+        origin = Point(0.0, 0.0)
+    for byte, key_vec in zip(data, key_stream):
+        pt_vec = AppliedVector(origin, Point(origin.x + float(byte), origin.y))
+        # addition uses AppliedVector.__add__, which keeps start == origin
+        yield pt_vec + key_vec
+
+
+def decrypt_bytes_stream(
+    cipher_stream: Iterable[AppliedVector],
+    key_stream: Iterable[AppliedVector],
+) -> Iterator[int]:
+    """Inverse of :func:`encrypt_bytes_stream`, yields raw byte values."""
+    for cipher_vec, key_vec in zip(cipher_stream, key_stream):
+        pt = cipher_vec - key_vec
+        yield int(pt.direction_vector.dx)

vector_crypt-0.1.0/vector_crypt/keygen.py

@@ -0,0 +1,94 @@
+from __future__ import annotations
+
+import random
+from typing import Iterable, Iterator, List, Optional
+
+from .classes import AppliedVector, AppliedVectorSet, Point
+
+
+# --- key generation ------------------------------------------------------------
+
+def generate_random_key(
+    num_vectors: int,
+    max_coord: float = 255.0,
+    origin: Optional[Point] = None,
+) -> AppliedVectorSet:
+    """Produce a random ``AppliedVectorSet`` containing ``num_vectors`` vectors.
+
+    Each vector starts at ``origin`` (default ``Point(0,0)``) and has an end
+    point whose coordinates are chosen uniformly from ``[-max_coord, max_coord]``.
+
+    Parameters
+    ----------
+    num_vectors
+        Number of vectors in the key; typically equal to the length of the
+        plaintext when encoding byte-wise.
+    max_coord
+        Maximum absolute value for each coordinate of the end point.  Smaller
+        values yield shorter vectors.
+    origin
+        Optional common starting point for all vectors.
+    """
+    if origin is None:
+        origin = Point(0.0, 0.0)
+
+    vecs: list[AppliedVector] = []
+    for _ in range(num_vectors):
+        dx = random.uniform(-max_coord, max_coord)
+        dy = random.uniform(-max_coord, max_coord)
+        end = Point(origin.x + dx, origin.y + dy)
+        vecs.append(AppliedVector(origin, end))
+    return AppliedVectorSet(vecs, origin=origin)
+
+
+def key_for_data(data: bytes, **kwargs) -> AppliedVectorSet:
+    """Convenience helper that generates a key matching the length of ``data``.
+
+    All keyword arguments are forwarded to :func:`generate_random_key`.
+    """
+    return generate_random_key(len(data), **kwargs)
+
+
+def generate_random_key_stream(
+    num_vectors: int,
+    max_coord: float = 255.0,
+    origin: Optional[Point] = None,
+) -> Iterator[AppliedVector]:
+    """Yield ``num_vectors`` random ``AppliedVector`` objects one by one.
+
+    This is useful for encrypting large blobs without materializing the entire
+    ``AppliedVectorSet`` in memory.  The caller can consume the stream in
+    chunks and assemble sets as needed.
+    """
+    if origin is None:
+        origin = Point(0.0, 0.0)
+
+    for _ in range(num_vectors):
+        dx = random.uniform(-max_coord, max_coord)
+        dy = random.uniform(-max_coord, max_coord)
+        end = Point(origin.x + dx, origin.y + dy)
+        yield AppliedVector(origin, end)
+
+
+def generate_batch_keys(
+    lengths: Iterable[int],
+    **kwargs,
+) -> List[AppliedVectorSet]:
+    """Return a list of random keys for each length in ``lengths``.
+
+    This helper is convenient when encrypting or decrypting a collection of
+    messages with independent keys.
+    """
+    return [generate_random_key(n, **kwargs) for n in lengths]
+
+
+def key_stream_for_data(
+    data: bytes,
+    **kwargs,
+) -> Iterator[AppliedVector]:
+    """Generate a stream of random vectors matching ``len(data)``.
+
+    Equivalent to ``generate_random_key_stream(len(data), **kwargs)`` but
+    named to echo :func:`key_for_data`.
+    """
+    yield from generate_random_key_stream(len(data), **kwargs)

vector_crypt-0.1.0/vector_crypt/vector_codec.py

@@ -0,0 +1,130 @@
+from __future__ import annotations
+
+from typing import Iterable, Iterator
+
+from .classes import AppliedVector, AppliedVectorSet, Point
+
+
+# --- data <-> vectors conversion ------------------------------------------------
+
+def bytes_to_vectors(data: bytes, origin: Point | None = None) -> AppliedVectorSet:
+    """Encode raw bytes into an AppliedVectorSet.
+
+    Each byte value is turned into a vector with dx equal to the byte and dy=0.
+    All vectors share a common ``origin`` (defaults to ``Point(0, 0)``).
+
+    This is a toy encoding; you can easily swap in a different mapping (e.g. two
+    bytes per vector, use dy for a second channel, etc.).
+    """
+    if origin is None:
+        origin = Point(0.0, 0.0)
+
+    vectors: list[AppliedVector] = []
+    for b in data:
+        end = Point(origin.x + float(b), origin.y)
+        vectors.append(AppliedVector(origin, end))
+    return AppliedVectorSet(vectors, origin=origin)
+
+
+def vectors_to_bytes(vectors: AppliedVectorSet) -> bytes:
+    """Decode a previously-encoded ``AppliedVectorSet`` back to bytes.
+
+    This function reverses :func:`bytes_to_vectors` and therefore will raise an
+    exception if the encoding scheme has changed or the set contains vectors
+    that do not have ``dy == 0`` or start at a consistent origin.
+    """
+    result = bytearray()
+    if len(vectors) == 0:
+        return bytes(result)
+
+    orig = vectors.origin or vectors.vectors[0].start_point
+    for av in vectors:
+        if av.start_point != orig:
+            raise ValueError("Inconsistent origin in AppliedVectorSet")
+        dx = av.direction_vector.dx
+        if av.direction_vector.dy != 0:
+            raise ValueError("Unexpected non-zero dy component")
+        if not (0 <= dx <= 255):
+            raise ValueError("dx value out of byte range: %r" % dx)
+        result.append(int(dx))
+
+    return bytes(result)
+
+
+def text_to_vectors(text: str, encoding: str = "utf-8", **kwargs) -> AppliedVectorSet:
+    """Convenience wrapper that encodes ``text`` using ``bytes_to_vectors``."""
+    return bytes_to_vectors(text.encode(encoding), **kwargs)
+
+
+def vectors_to_text(vectors: AppliedVectorSet, encoding: str = "utf-8") -> str:
+    """Convenience wrapper that decodes vectors back to a string."""
+    return vectors_to_bytes(vectors).decode(encoding)
+
+
+# streaming helpers -----------------------------------------------------------
+
+def bytes_to_vectors_stream(
+    data: Iterable[int], origin: Point | None = None
+) -> Iterator[AppliedVector]:
+    """Yield vectors corresponding to each byte in ``data``.
+
+    ``data`` may be any iterable of integer values in ``0..255``; typical use
+    is to pass a ``bytes`` or ``bytearray`` object.  The caller can wrap the
+    output in an :class:`AppliedVectorSet` if desired.
+    """
+    if origin is None:
+        origin = Point(0.0, 0.0)
+    for b in data:
+        end = Point(origin.x + float(b), origin.y)
+        yield AppliedVector(origin, end)
+
+
+def vectors_to_bytes_stream(
+    vectors: Iterable[AppliedVector],
+    origin: Point | None = None,
+) -> Iterator[int]:
+    """Yield integer byte values from an iterable of vectors.
+
+    This is the streaming counterpart to :func:`vectors_to_bytes` and is
+    useful when processing large sequences without collecting them all first.
+    ``origin`` may be specified to validate start points.
+    """
+    first = True
+    for av in vectors:
+        if first:
+            first = False
+            if origin is None:
+                origin = av.start_point
+        if av.start_point != origin:
+            raise ValueError("Inconsistent origin in stream")
+        if av.direction_vector.dy != 0:
+            raise ValueError("Unexpected non-zero dy component")
+        dx = av.direction_vector.dx
+        if not (0 <= dx <= 255):
+            raise ValueError("dx value out of byte range: %r" % dx)
+        yield int(dx)
+
+
+# file helpers ---------------------------------------------------------------
+
+def file_to_vectors(path: str, chunk_size: int = 4096) -> Iterator[AppliedVector]:
+    """Read a file and yield vectors for its bytes in chunks.
+
+    The file is opened in binary mode and read incrementally to avoid large
+    memory consumption.  ``chunk_size`` controls how many bytes are read at a
+    time.
+    """
+    origin = Point(0.0, 0.0)
+    with open(path, "rb") as f:
+        while True:
+            chunk = f.read(chunk_size)
+            if not chunk:
+                break
+            yield from bytes_to_vectors_stream(chunk, origin=origin)
+
+
+def vectors_to_file(vectors: Iterable[AppliedVector], path: str):
+    """Write vector data back to a file as raw bytes."""
+    with open(path, "wb") as f:
+        for byte in vectors_to_bytes_stream(vectors):
+            f.write(bytes((byte,)))

vector_crypt-0.1.0/vector_crypt.egg-info/PKG-INFO

@@ -0,0 +1,116 @@
+Metadata-Version: 2.4
+Name: vector_crypt
+Version: 0.1.0
+Summary: A toy cryptographic library encoding data as applied vector sets.
+Author-email: Sagu4ka <sagu4ka@gmail.com>
+License: MIT
+Keywords: cryptography,vector,encoding,one-time-pad
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# Applied-Vector Crypto (`vector_crypt`)
+
+A lightweight Python library demonstrating a **novel cryptographic
+principle**: represent both plaintext and keys as _sets of applied vectors_
+and perform encryption simply by vector addition.  The package is intended as
+an educational toy, a research starting point, or a playful experiment rather
+than a drop-in replacement for real-world ciphers.
+
+## 🚀 Основная идея
+
+Каждый байт (или символ, блок) сообщения кодируется как
+**`AppliedVector`** — отрезок с фиксированным началом и направлением.  Ключ
+тоже является набором таких векторов.  Шифрование сводится к поэлементному
+сложению двух наборов (похожим на операцию `XOR` для чисел), а расшифровка –
+к вычитанию.
+
+*В отличие от большинства алгоритмов, здесь информация представлена геометрически,
+что даёт визуализацию, естественное расширение на многомерность и простой
+потоковый интерфейс.*
+
+### Почему это уникально?
+
+- **Геометрическое представление.**  Традиционные симметричные схемы оперируют
+  на битах и байтах.  Мы работаем с векторами, что позволяет легко вводить
+  масштабирование, вращения, линейные преобразования и работать в произвольных
+  пространствах (включая конечные поля).
+
+- **Простота.**  Всего пара строк кода даёт шифрование/дешифровку.  Нет S‑боксов,
+  нет ключевого расписания, только алгебра над векторами.
+
+- **Потоковая обработка.**  Код поддерживает генераторы, чтение/запись файлов
+  по кускам и пакетные операции, что пригодится для больших данных.
+
+- **Проверяемость.**  Отображение вектор‑множества на экран, графы, SVG…
+  Приятно для обучения и визуальных демо.
+
+## 🔍 Схожие идеи в криптографии
+
+- **One‑time pad / Vernam cipher.**  Байт сообщения прибавляется к байту ключа
+  по модулю 2⁸; наша операция аналогична, но мы «вырастаем» в векторное
+  пространство и сохраняем абсолютную информацию в промежуточном виде (можно
+  наложить дополнительные операции).
+
+- **Кодировка векторов в стойкие каналы.**  В теории информации часто
+  рассматривают передаваемые сигналы как точки в \\Rⁿ; в этом смысле наше
+  шифрование — частный случай линейного кодирования.
+
+- **Графовые шифры.**  В гомоморфных системах используются линейные операции;
+  наш механизм легко расширяется до гомоморфизма над векторным пространством.
+
+Однако: мы не претендуем на криптостойкость, а скорее демонстрируем новый
+формальный подход.  Внедрить в реальную систему потребует серьёзного
+криптоанализа и, вероятно, модификаций (например, работа в конечных полях,
+нелинейные слои и т. д.).
+
+## 🧩 Структура проекта
+
+```
+vector_crypt/        # репозиторий
+├── vector_crypt/     # собственно пакет Python
+│   ├── __init__.py
+│   ├── classes.py
+│   ├── endecode.py
+│   ├── keygen.py
+│   └── vector_codec.py
+├── tests/            # простые тесты (пока минимум)
+├── README.md         # вы читаете
+├── LICENSE           # MIT
+└── pyproject.toml    # сборка/метаданные
+```
+
+## ⚙️ Установка и использование
+
+```bash
+pip install vector_crypt
+```
+
+```python
+from vector_crypt import encrypt_text, decrypt_text, key_for_data
+
+key = key_for_data(b"secret message")
+cipher = encrypt_text("hello", key)
+print(decrypt_text(cipher, key))  # hello
+```
+
+Для потокового шифрования используйте `encrypt_bytes_stream` вместе с
+`generate_random_key_stream`.
+
+## 📝 Где использовать
+
+Библиотека подходит для:
+
+* учебных примеров и лекций по основам криптографии;
+* прототипирования альтернативных представлений данных (векторов вместо
+  скаляров);
+* демонстраций визуализации шифрования в 2D/3D;
+* утилит, где требуется совместное хранение геометрической информации и
+  шифрования (например, защитить набор координат).
+
+Не рекомендуется применять `vector_crypt` для защиты реальных данных без
+дополнительного анализа.

vector_crypt-0.1.0/vector_crypt.egg-info/SOURCES.txt

@@ -0,0 +1,13 @@
+LICENSE
+README.md
+pyproject.toml
+tests/test_basic.py
+vector_crypt/__init__.py
+vector_crypt/classes.py
+vector_crypt/endecode.py
+vector_crypt/keygen.py
+vector_crypt/vector_codec.py
+vector_crypt.egg-info/PKG-INFO
+vector_crypt.egg-info/SOURCES.txt
+vector_crypt.egg-info/dependency_links.txt
+vector_crypt.egg-info/top_level.txt

vector_crypt-0.1.0/vector_crypt.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

vector_crypt-0.1.0/vector_crypt.egg-info/top_level.txt

@@ -0,0 +1 @@
+vector_crypt