PyIntell 0.1.0__py3-none-any.whl

pyintell/utilities.py

@@ -0,0 +1,444 @@
+"""General-purpose tensor, data, metrics, and model utility functions."""
+
+import json
+import os
+import numpy as np
+
+
+def tensor(data, dtype=None):
+    return np.asarray(data, dtype=dtype)
+
+
+def zeros(shape, dtype=np.float32):
+    return np.zeros(shape, dtype=dtype)
+
+
+def ones(shape, dtype=np.float32):
+    return np.ones(shape, dtype=dtype)
+
+
+def full(shape, value, dtype=None):
+    return np.full(shape, value, dtype=dtype)
+
+
+def random(shape, dtype=np.float32):
+    return np.random.random(shape).astype(dtype)
+
+
+def randn(shape, dtype=np.float32):
+    return np.random.randn(*shape).astype(dtype)
+
+
+def randint(low, high=None, size=None, dtype=np.int64):
+    return np.random.randint(low, high, size=size, dtype=dtype)
+
+
+def arange(*args, **kwargs):
+    return np.arange(*args, **kwargs)
+
+
+def reshape(x, shape):
+    return np.reshape(x, shape)
+
+
+def flatten(x):
+    return np.asarray(x).reshape(-1)
+
+
+def squeeze(x, axis=None):
+    return np.squeeze(x, axis=axis)
+
+
+def unsqueeze(x, axis):
+    return np.expand_dims(x, axis=axis)
+
+
+def transpose(x, axes=None):
+    return np.transpose(x, axes=axes)
+
+
+def permute(x, axes):
+    return np.transpose(x, axes=axes)
+
+
+def matmul(a, b):
+    return np.matmul(a, b)
+
+
+def dot(a, b):
+    return np.dot(a, b)
+
+
+def sum(x, axis=None, keepdims=False):
+    return np.sum(x, axis=axis, keepdims=keepdims)
+
+
+def mean(x, axis=None, keepdims=False):
+    return np.mean(x, axis=axis, keepdims=keepdims)
+
+
+def max(x, axis=None, keepdims=False):
+    return np.max(x, axis=axis, keepdims=keepdims)
+
+
+def min(x, axis=None, keepdims=False):
+    return np.min(x, axis=axis, keepdims=keepdims)
+
+
+def argmax(x, axis=None):
+    return np.argmax(x, axis=axis)
+
+
+def argmin(x, axis=None):
+    return np.argmin(x, axis=axis)
+
+
+def clip(x, minimum, maximum):
+    return np.clip(x, minimum, maximum)
+
+
+def sqrt(x):
+    return np.sqrt(x)
+
+
+def exp(x):
+    return np.exp(x)
+
+
+def log(x):
+    return np.log(x)
+
+
+def abs(x):
+    return np.abs(x)
+
+
+def power(x, exponent):
+    return np.power(x, exponent)
+
+
+def cat(tensors, axis=0):
+    return np.concatenate(tensors, axis=axis)
+
+
+def stack(tensors, axis=0):
+    return np.stack(tensors, axis=axis)
+
+
+def split(x, sections, axis=0):
+    return np.array_split(x, sections, axis=axis)
+
+
+def chunk(x, chunks, axis=0):
+    return np.array_split(x, chunks, axis=axis)
+
+
+def repeat(x, repeats, axis=None):
+    return np.repeat(x, repeats, axis=axis)
+
+
+def expand(x, shape):
+    return np.broadcast_to(x, shape)
+
+
+def pad(x, padding, constant=0):
+    return np.pad(x, padding, constant_values=constant)
+
+
+def roll(x, shift, axis=None):
+    return np.roll(x, shift, axis=axis)
+
+
+def gather(x, indices, axis=0):
+    return np.take(x, indices, axis=axis)
+
+
+def scatter(x, indices, values, axis=0):
+    result = np.array(x, copy=True)
+    np.put_along_axis(result, np.asarray(indices), np.asarray(values), axis=axis)
+    return result
+
+
+def where(condition, x, y):
+    return np.where(condition, x, y)
+
+
+def masked_fill(x, mask, value):
+    return np.where(mask, x, value)
+
+
+def einsum(expression, *operands):
+    return np.einsum(expression, *operands)
+
+
+def norm(x, axis=None, keepdims=False):
+    return np.linalg.norm(x, axis=axis, keepdims=keepdims)
+
+
+def normalize(x, axis=-1, eps=1e-12):
+    x = np.asarray(x)
+    return x / np.maximum(norm(x, axis=axis, keepdims=True), eps)
+
+
+def device():
+    return "cpu"
+
+
+def cpu():
+    return "cpu"
+
+
+def gpu():
+    return None
+
+
+def to_device(x, target="cpu"):
+    if str(target).lower() != "cpu":
+        raise RuntimeError("GPU backends are not included in the NumPy-only release")
+    return x
+
+
+def seed(value):
+    np.random.seed(value)
+
+
+def set_seed(value):
+    seed(value)
+
+
+def random_seed(value=None):
+    if value is None:
+        value = int.from_bytes(os.urandom(8), "little")
+    seed(value)
+    return value
+
+
+def accuracy(predictions, targets):
+    p = np.asarray(predictions)
+    t = np.asarray(targets)
+    if p.ndim > t.ndim:
+        p = np.argmax(p, axis=-1)
+    return float(np.mean(p == t))
+
+
+def precision(predictions, targets):
+    p, t = np.asarray(predictions).astype(bool), np.asarray(targets).astype(bool)
+    tp = np.sum(p & t)
+    fp = np.sum(p & ~t)
+    return float(tp / (tp + fp)) if tp + fp else 0.0
+
+
+def recall(predictions, targets):
+    p, t = np.asarray(predictions).astype(bool), np.asarray(targets).astype(bool)
+    tp = np.sum(p & t)
+    fn = np.sum(~p & t)
+    return float(tp / (tp + fn)) if tp + fn else 0.0
+
+
+def f1_score(predictions, targets):
+    p = precision(predictions, targets)
+    r = recall(predictions, targets)
+    return 2 * p * r / (p + r) if p + r else 0.0
+
+
+def perplexity(loss_value):
+    return float(np.exp(loss_value))
+
+
+def model_size(parameters, dtype="float32"):
+    sizes = {"float64": 8, "float32": 4, "float16": 2, "bfloat16": 2, "int8": 1, "int4": 0.5}
+    return int(np.ceil(int(parameters) * sizes[str(dtype).lower()]))
+
+
+def count_parameters(model):
+    return int(getattr(model, "parameters", 0))
+
+
+def trainable_parameters(model):
+    return count_parameters(model)
+
+
+def parameter_shapes(model):
+    return {name: value.shape for name, value in vars(model).items() if isinstance(value, np.ndarray)}
+
+
+def memory_usage(model):
+    return sum(value.nbytes for value in vars(model).values() if isinstance(value, np.ndarray))
+
+
+def model_info(model):
+    return model.summary() if hasattr(model, "summary") else {"parameters": count_parameters(model)}
+
+
+def summary(model):
+    return model_info(model)
+
+
+def save_config(config, path):
+    with open(path, "w", encoding="utf-8") as file:
+        json.dump(config, file, indent=2)
+
+
+def load_config(path):
+    with open(path, "r", encoding="utf-8") as file:
+        return json.load(file)
+
+
+def read_text(path, encoding="utf-8"):
+    with open(path, "r", encoding=encoding) as file:
+        return file.read()
+
+
+def write_text(path, text, encoding="utf-8"):
+    with open(path, "w", encoding=encoding) as file:
+        file.write(text)
+
+
+def load_text(path, encoding="utf-8"):
+    return read_text(path, encoding)
+
+
+def save_text(path, text, encoding="utf-8"):
+    return write_text(path, text, encoding)
+
+
+def normalize_text(text):
+    return " ".join(str(text).split())
+
+
+def clean_text(text):
+    return normalize_text(text)
+
+
+def lower_text(text):
+    return str(text).lower()
+
+
+def uppercase(text):
+    return str(text).upper()
+
+
+def split_sentences(text):
+    return [part.strip() for part in str(text).replace("!", ".").replace("?", ".").split(".") if part.strip()]
+
+
+def split_words(text):
+    return str(text).split()
+
+
+def chunk_text(text, size):
+    words = split_words(text)
+    return [" ".join(words[i:i + size]) for i in range(0, len(words), size)]
+
+
+def truncate_text(text, max_words):
+    return " ".join(split_words(text)[:max_words])
+
+
+def pad_sequence(sequence, length, value=0):
+    result = list(sequence)[:length]
+    return result + [value] * max(0, length - len(result))
+
+
+def create_mask(length, causal=False):
+    if causal:
+        return np.tril(np.ones((length, length), dtype=bool))
+    return np.ones((length, length), dtype=bool)
+
+
+def shuffle(data, seed_value=None):
+    items = list(data)
+    rng = np.random.default_rng(seed_value)
+    rng.shuffle(items)
+    return items
+
+
+def split_dataset(data, train_ratio=0.8, validation_ratio=0.1):
+    items = list(data)
+    n = len(items)
+    a = int(n * train_ratio)
+    b = a + int(n * validation_ratio)
+    return items[:a], items[a:b], items[b:]
+
+
+def batch(data, batch_size):
+    items = list(data)
+    return [items[i:i + batch_size] for i in range(0, len(items), batch_size)]
+
+
+def dataset(data):
+    return list(data)
+
+
+def load_dataset(data):
+    return dataset(data)
+
+
+def save_dataset(data, path):
+    np.save(path, np.asarray(data, dtype=object), allow_pickle=True)
+
+
+def cache(data):
+    return list(data)
+
+
+def filter_dataset(data, predicate):
+    return [item for item in data if predicate(item)]
+
+
+def map_dataset(data, function):
+    return [function(item) for item in data]
+
+
+def temperature(logits, value=1.0):
+    if value <= 0:
+        raise ValueError("temperature must be greater than zero")
+    return np.asarray(logits) / value
+
+
+def top_k(logits, k):
+    values = np.asarray(logits)
+    if k <= 0:
+        raise ValueError("k must be positive")
+    indices = np.argpartition(values, -min(k, values.size))[-min(k, values.size):]
+    return indices
+
+
+def top_p(logits, p=0.9):
+    values = np.asarray(logits, dtype=np.float64)
+    if not 0 < p <= 1:
+        raise ValueError("p must be in the range (0, 1]")
+    order = np.argsort(values)[::-1]
+    shifted = values[order] - np.max(values)
+    probs = np.exp(shifted)
+    probs /= probs.sum()
+    cumulative = np.cumsum(probs)
+    return order[cumulative <= p] if np.any(cumulative <= p) else order[:1]
+
+
+def repetition_penalty(logits, token_ids, penalty=1.1):
+    values = np.array(logits, dtype=np.float64, copy=True)
+    for token_id in set(token_ids):
+        if 0 <= token_id < len(values):
+            values[token_id] = values[token_id] / penalty if values[token_id] > 0 else values[token_id] * penalty
+    return values
+
+
+def frequency_penalty(logits, token_ids, penalty=0.0):
+    values = np.array(logits, dtype=np.float64, copy=True)
+    for token_id in token_ids:
+        if 0 <= token_id < len(values):
+            values[token_id] -= penalty
+    return values
+
+
+def presence_penalty(logits, token_ids, penalty=0.0):
+    values = np.array(logits, dtype=np.float64, copy=True)
+    for token_id in set(token_ids):
+        if 0 <= token_id < len(values):
+            values[token_id] -= penalty
+    return values
+
+
+def stop_at_token(token_id, stop_tokens):
+    return token_id in set(stop_tokens)

pyintell-0.1.0.dist-info/METADATA

@@ -0,0 +1,226 @@
+Metadata-Version: 2.4
+Name: PyIntell
+Version: 0.1.0
+Summary: A modular NumPy-based Python framework for building, training, evaluating, and generating from AI models
+Author: Leila150
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/Leila150/PyIntell
+Project-URL: Repository, https://github.com/Leila150/PyIntell
+Project-URL: Issues, https://github.com/Leila150/PyIntell/issues
+Keywords: ai,machine-learning,deep-learning,transformer,neural-network,nlp,numpy
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy>=1.24
+Provides-Extra: system
+Requires-Dist: psutil>=5.9; extra == "system"
+Dynamic: license-file
+
+# PyIntell
+
+**PyIntell** is a modular NumPy-based Python framework for building, experimenting with, evaluating, training, and generating from AI/Transformer-style models.
+
+> **Status:** `0.1.0` — Alpha. The public API is available for experimentation. Some advanced training, autograd, quantization, and hardware features are lightweight/experimental rather than production-grade.
+
+## Installation
+
+The **PyPI project name is `PyIntell`**.
+
+```bash
+pip install PyIntell
+```
+
+The Python import name is **`pyintell`**:
+
+```python
+import pyintell
+```
+
+This distinction is important: **install `PyIntell`, import `pyintell`.**
+
+## Quick start
+
+```python
+import pyintell
+
+model = pyintell.build(
+    vocab={"hello": 0, "world": 1},
+    reverse_vocab={0: "hello", 1: "world"},
+    dataset=[[0, 1]],
+    parameters=100_000,
+    focus=["coding", "reasoning", "math"],
+)
+
+print(model.summary())
+print(model.generate("hello"))
+```
+
+## Main builder
+
+```python
+pyintell.build(
+    vocab,
+    reverse_vocab,
+    dataset,
+    parameters,
+    focus,
+    dtype=None,
+    settings=None,
+)
+```
+
+`build()` constructs a `Model` from a vocabulary, reverse vocabulary, dataset, requested parameter count, focus, numerical dtype, and optional settings.
+
+## Focus system
+
+Focus profiles are exposed through `SUPPORTED_FOCUSES` and `FOCUS_PROFILES`. Focus utilities include:
+
+- `normalize_focus()`
+- `build_focus_config()`
+- `focus_description()`
+
+Multiple focuses are supported:
+
+```python
+focus=["coding", "reasoning", "math"]
+```
+
+Models can also expose and modify focus through `get_focus()`, `set_focus()`, `focus_scores()`, and `focus_info()`.
+
+## Public API
+
+The `PyIntell` distribution exposes the Python package `pyintell`. Its public API includes the following functional areas.
+
+### Model and building
+
+`Model`, `build`, `named_parameters`, `parameter_count`, `parameters_info`, `summary`, `model_info`, `model_size`, `count_parameters`, `parameter_shapes`, `set_current_model`, and model-management helpers.
+
+### Tokenization
+
+`tokenizer`, `tokenize`, `tokenize_batch`, `detokenize`, `detokenize_batch`, `vocab`, `build_vocab`, `update_vocab`, `merge_vocab`, `reverse_vocab`, `vocab_size`, `token_id`, `id_token`, `token_exists`, `add_token`, `remove_token`, `special_tokens`, `add_special_token`, `encode`, `encode_batch`, `decode`, `decode_batch`, `normalize_text`, `clean_text`, `split_text`, `split_words`, `split_sentences`, `chunk_text`, `truncate`, `truncate_text`, `lower_text`, `uppercase`, and `pad_sequence`.
+
+### Embeddings
+
+`embedding`, `embeddings`, `positional_embedding`, `position_embedding`, `sinusoidal_embedding`, `rotary_embedding`, and `embedding_similarity`.
+
+### Attention and Transformer
+
+`attention`, `scaled_dot_product_attention`, `self_attention`, `cross_attention`, `multihead_attention`, `multi_query_attention`, `grouped_query_attention`, `causal_attention`, `local_attention`, `global_attention`, `sparse_attention`, `sliding_window_attention`, `block_attention`, `flash_attention`, `rotary_attention`, `alibi_attention`, `attention_mask`, `causal_mask`, `padding_mask`, `transformer_block`, and `transformer`.
+
+### Layers and activations
+
+`linear`, `activation`, `relu`, `gelu`, `sigmoid`, `tanh`, `leaky_relu`, `softplus`, `silu`, `swish`, `mish`, `softmax`, `log_softmax`, `layer_norm`, `batch_norm`, `rms_norm`, `dropout`, `flatten_layer`, `feedforward`, `mlp`, `residual`, and `residual_block`.
+
+### Losses and metrics
+
+`loss`, `cross_entropy`, `binary_cross_entropy`, `mse`, `mae`, `huber_loss`, `kl_divergence`, `contrastive_loss`, `label_smoothing`, `perplexity`, `accuracy`, `f1_score`, and `recall`.
+
+### Tensor and numerical operations
+
+`tensor`, `zeros`, `ones`, `full`, `random`, `randn`, `randint`, `arange`, `reshape`, `flatten`, `squeeze`, `unsqueeze`, `transpose`, `permute`, `repeat`, `expand`, `pad`, `roll`, `cat`, `stack`, `split`, `chunk`, `matmul`, `dot`, `sum`, `mean`, `max`, `min`, `argmax`, `argmin`, `clip`, `sqrt`, `exp`, `log`, `abs`, `power`, `norm`, `normalize`, `einsum`, `where`, `masked_fill`, `gather`, and `scatter`.
+
+### Autograd
+
+`gradient`, `compute_gradients`, `numerical_gradient`, `backward`, `requires_grad`, `detach`, `no_grad`, and `zero_grad`.
+
+### Optimizers and scheduling
+
+`Optimizer`, `optimizer`, `sgd`, `adam`, `adamw`, `rmsprop`, `adagrad`, `update_weights`, `step`, `learning_rate`, `weight_decay`, `gradient_clipping`, `lr_scheduler`, `constant_lr`, `linear_decay`, `cosine_decay`, and `warmup`.
+
+### Dataset and training
+
+`dataset`, `load_dataset`, `save_dataset`, `split_dataset`, `shuffle`, `batch`, `map_dataset`, `filter_dataset`, `cache`, `train`, and `evaluate`.
+
+### Generation
+
+`generate`, `sample`, `temperature`, `top_k`, `top_p`, `repetition_penalty`, `frequency_penalty`, `presence_penalty`, `stop_at_token`, `get_model`, and `model_run`.
+
+### Serialization and storage
+
+`save`, `load`, `save_model`, `load_model`, `delete_model`, `edit_model`, `save_weights`, `load_weights`, `state_dict`, `load_state_dict`, `serialize`, `deserialize`, `save_config`, `load_config`, `save_checkpoint`, `load_checkpoint`, `checkpoint`, `export_model`, `import_model`, `save_text`, `load_text`, `read_text`, and `write_text`.
+
+### Quantization and fine-tuning
+
+`quantization`, `quantize`, `dequantize`, `int4`, `int8`, `float16`, `bfloat16`, `finetune`, `finetuning`, `parameter_efficient_finetuning`, `lora`, `qlora`, `adapter`, `low_rank`, `prefix_tuning`, `prompt_tuning`, `freeze`, `unfreeze`, `freeze_layers`, `unfreeze_layers`, `trainable`, `trainable_parameters`, `prune`, `sparsify`, and `factorize`.
+
+### System and devices
+
+`device`, `to_device`, `cpu`, `gpu`, `cuda`, `device_count`, `device_info`, `is_gpu_available`, `cpu_info`, `gpu_info`, `cpu_memory`, `gpu_memory`, `memory_info`, `memory_usage`, `free_memory`, `clear_cache`, `ram`, `storage_info`, and `system_info`.
+
+### Reproducibility
+
+`seed`, `set_seed`, and `random_seed` control random initialization and reproducibility.
+
+```python
+pyintell.set_seed(42)
+```
+
+## Package layout
+
+The project uses a `src` layout. The **distribution name is `PyIntell`**, and the **Python package/import name is `pyintell`**.
+
+```text
+PyIntell/
+├── src/
+│   └── pyintell/
+├── .github/
+│   └── workflows/
+│       └── release.yml
+├── pyproject.toml
+├── README.md
+└── LICENSE
+```
+
+## PyPI publishing
+
+PyPI publication is automated through GitHub Actions and PyPI Trusted Publishing.
+
+Workflow:
+
+```text
+.github/workflows/release.yml
+```
+
+The release workflow:
+
+1. Checks out the repository.
+2. Sets up Python.
+3. Installs `build` and `twine`.
+4. Builds source and wheel distributions.
+5. Runs `twine check` against the distributions.
+6. Publishes the distributions to the `PyIntell` PyPI project using Trusted Publishing.
+
+A GitHub Release with the `published` event triggers the workflow. It can also be started manually with `workflow_dispatch`.
+
+## Requirements
+
+- Python `>=3.9`
+- NumPy `>=1.24`
+- Optional: `psutil>=5.9` for system-related functionality
+
+## Status
+
+**pyintell `0.1.0` Alpha**
+
+The project is intended for experimentation and development. The Alpha API may evolve before a stable release.
+
+## Repository
+
+GitHub: https://github.com/Leila150/PyIntell
+
+## License
+
+MIT License. See `LICENSE` for the full license text.

pyintell-0.1.0.dist-info/RECORD

@@ -0,0 +1,25 @@
+pyintell/__init__.py,sha256=-IwjC_uTUmQSmSELtUB3OHy18rxbUMLAG9sNv6a-Omc,872
+pyintell/attention.py,sha256=_UN6hn2ffU7IiW_C-Tz9XomOywK3_xZaqJ58qe9Vp1g,3784
+pyintell/autograd.py,sha256=fcLyi3wRwPrg7WxdUK95KfsyVGXzUVZ4FYS46uc9D60,1301
+pyintell/builder.py,sha256=Zu88uuKeYaVjys6Gos93PEx8vsQeNeXlnF1ETi-PiHM,10159
+pyintell/embeddings.py,sha256=earu3AgFSwoTmhqoNjcUXcq766NiMd5TCnj08jzCh84,1383
+pyintell/finetuning.py,sha256=Sgg28A01aRbdZlDL7LuDr7XG9fv-J72gqmrVslWVA5o,1871
+pyintell/focus.py,sha256=n7aBCNneFfHZQUHW00mMSutaL2WZU6bBjR7PtzJ8H_Y,3517
+pyintell/generation.py,sha256=I24UrQvYAh62CB3njDrapEPosd3LCFsNR8O1QLRkHBg,2867
+pyintell/layers.py,sha256=MEkK2Yp7c_qWlmhHNVuFaKSXek5n0pFY5LGHnkppnZE,2935
+pyintell/loss.py,sha256=tXSqrJ4wvTUUMojIze7GgUsDhx_4Y1QveB3qjw6fO_Q,2097
+pyintell/model.py,sha256=2b2wdv6mBtAXBY0e6YainuN2wGkzLDn5wd4MnRhiJ8M,11681
+pyintell/optim.py,sha256=hTBoLQ2A0Hy_TiftzUHwO1MceLSpyCFnUxpjXLiY8OE,4700
+pyintell/quantization.py,sha256=15Y6zqwcDCgxjYlpoz1zZKhJOvAxNh0o_2l5CWXVuTk,1169
+pyintell/scheduling.py,sha256=o2LkIYLb3PMKRx_tACY_mIF2AjooizhQY8d3NSAd_Ok,864
+pyintell/serialization.py,sha256=vbEBPfFN05TsPXWJIJ4fR6N1LiXsDjJSVWBWngy3w_w,9848
+pyintell/system.py,sha256=lk67thBEhAq8CgMJrgwSDN9DkJPbCt-6aK4EfxXcWGU,2983
+pyintell/tokenization.py,sha256=QMMYhGzWgxvlrQu2NDKODjTkmmaV_DvfZHCC567Ho5I,3473
+pyintell/training.py,sha256=Htv2DNl3XL2hwl_nGF3yUPTTlRCqmvr1Tbk84SG51-k,526
+pyintell/transformer.py,sha256=gqfmDKsUHcMSzdsGyuo-QVne3vfknI9z0mHWKQGVyaY,4081
+pyintell/utilities.py,sha256=qDPU9lhHPg7ubYOus5JWRRO-PMh6VMJNKdKRzKqpH8U,9686
+pyintell-0.1.0.dist-info/licenses/LICENSE,sha256=u9PxYqT3h-Ucs9FlBXHTglV63_1y6yDdp7Fs1JevEhU,1065
+pyintell-0.1.0.dist-info/METADATA,sha256=wgG-7xbmTWnuzNbhhQ0jod_MrkAHIVmTtyDlycvmWNo,8663
+pyintell-0.1.0.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+pyintell-0.1.0.dist-info/top_level.txt,sha256=rftHPOtYxxPR-brWU1GZP9MbDW6F2grrY_tWfB4h_y0,9
+pyintell-0.1.0.dist-info/RECORD,,

pyintell-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+