nzachapy 0.1.0__tar.gz

nzachapy-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Leonard's Venture
+
+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.

nzachapy-0.1.0/PKG-INFO

@@ -0,0 +1,124 @@
+Metadata-Version: 2.4
+Name: nzachapy
+Version: 0.1.0
+Summary: Context filtering module that scans your data and returns only relevant portions based on a query.
+Author: Leonard Nwosu
+Project-URL: Homepage, https://github.com/Dblvcksheep/nzachapy
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy
+Requires-Dist: sentence-transformers
+Requires-Dist: openai
+Requires-Dist: httpx
+Dynamic: license-file
+
+# nzachapy
+
+> **Context Filtering for LLMs** — Scan your entire dataset and return only the portion relevant to your query.
+
+When working with large datasets and language models, stuffing everything into the context window is noisy and expensive. `nzachapy` solves this by chunking your data, embedding it semantically, and returning only the chunks most relevant to a given query — so your model sees signal, not noise.
+
+---
+
+## Installation
+
+```bash
+pip install nzachapy
+```
+
+---
+
+## Quick Start
+
+```python
+from nzachapy import Nzacha
+
+# Initialize the module
+nz = Nzacha()
+
+# Add your dataset (must be a string)
+nz.add_by_words(data)
+
+# Query for relevant context
+results = nz.query("your query here")
+```
+
+> ⚠️ **Important:** Your dataset must be converted to a string before passing it to `add_by_words()`.
+
+---
+
+## Configuration
+
+When initializing `Nzacha`, you can customize the following parameters. If left unset, the defaults are used.
+
+| Parameter | Default | Description |
+|---|---|---|
+| `chunk_size` | `200` | Number of words per chunk |
+| `overlap` | `20` | Number of overlapping words between consecutive chunks |
+| `openai_api_key` | `None` | OpenAI API key for semantic embeddings (optional) |
+| `threshold` | `0.6` | Minimum similarity score for a chunk to be returned |
+
+### Example with custom config
+
+```python
+nz = Nzacha(
+    chunk_size=150,
+    overlap=30,
+    openai_api_key="sk-...",
+    threshold=0.75
+)
+```
+
+---
+
+## Embedding Backends
+
+`nzachapy` supports two embedding strategies:
+
+- **OpenAI** — Provide your `openai_api_key` at initialization to use OpenAI's embedding models for higher-quality semantic search.
+- **Sentence Transformers** *(default)* — If no API key is provided, the module falls back to a local `sentence-transformers` model. No API key required.
+
+---
+
+## How It Works
+
+1. **Chunking** — `add_by_words(data)` splits your string dataset into overlapping word-based chunks. `chunk_size` controls how many words each chunk contains; `overlap` controls how many words are shared between adjacent chunks to preserve context across boundaries.
+
+2. **Embedding** — Each chunk is embedded into a vector using either OpenAI or Sentence Transformers.
+
+3. **Retrieval** — When you run a query, it is embedded the same way and compared against all chunk embeddings. Only chunks that meet or exceed the `threshold` similarity score are returned.
+
+---
+
+## API Reference
+
+### `Nzacha(chunk_size, overlap, openai_api_key, threshold)`
+Initializes the context filter with the given configuration.
+
+### `nz.add_by_words(data: str)`
+Chunks the provided string dataset by word count and stores the embeddings internally. Must be called before querying.
+
+- `data` — Your full dataset as a **string**. Convert lists, dicts, DataFrames, or any other structure to a string first.
+
+---
+
+## Notes
+
+- Always pass data as a plain string. Use `str()`, `json.dumps()`, or `.to_string()` (for DataFrames) to convert before calling `add_by_words()`.
+- A lower `threshold` returns more (but less precise) chunks. A higher threshold is stricter.
+- Chunk `overlap` helps avoid losing context that falls on chunk boundaries — tune it based on your data's structure.
+
+---
+
+## Contributing
+
+Contributions are welcome! If you spot an area for improvement — whether it's a new chunking strategy, a better embedding backend, performance optimizations, or additional retrieval methods — feel free to open an issue or submit a pull request.
+
+Please make sure any changes are well-tested and clearly documented.
+
+---
+
+## License
+
+MIT

nzachapy-0.1.0/README.md

@@ -0,0 +1,109 @@
+# nzachapy
+
+> **Context Filtering for LLMs** — Scan your entire dataset and return only the portion relevant to your query.
+
+When working with large datasets and language models, stuffing everything into the context window is noisy and expensive. `nzachapy` solves this by chunking your data, embedding it semantically, and returning only the chunks most relevant to a given query — so your model sees signal, not noise.
+
+---
+
+## Installation
+
+```bash
+pip install nzachapy
+```
+
+---
+
+## Quick Start
+
+```python
+from nzachapy import Nzacha
+
+# Initialize the module
+nz = Nzacha()
+
+# Add your dataset (must be a string)
+nz.add_by_words(data)
+
+# Query for relevant context
+results = nz.query("your query here")
+```
+
+> ⚠️ **Important:** Your dataset must be converted to a string before passing it to `add_by_words()`.
+
+---
+
+## Configuration
+
+When initializing `Nzacha`, you can customize the following parameters. If left unset, the defaults are used.
+
+| Parameter | Default | Description |
+|---|---|---|
+| `chunk_size` | `200` | Number of words per chunk |
+| `overlap` | `20` | Number of overlapping words between consecutive chunks |
+| `openai_api_key` | `None` | OpenAI API key for semantic embeddings (optional) |
+| `threshold` | `0.6` | Minimum similarity score for a chunk to be returned |
+
+### Example with custom config
+
+```python
+nz = Nzacha(
+    chunk_size=150,
+    overlap=30,
+    openai_api_key="sk-...",
+    threshold=0.75
+)
+```
+
+---
+
+## Embedding Backends
+
+`nzachapy` supports two embedding strategies:
+
+- **OpenAI** — Provide your `openai_api_key` at initialization to use OpenAI's embedding models for higher-quality semantic search.
+- **Sentence Transformers** *(default)* — If no API key is provided, the module falls back to a local `sentence-transformers` model. No API key required.
+
+---
+
+## How It Works
+
+1. **Chunking** — `add_by_words(data)` splits your string dataset into overlapping word-based chunks. `chunk_size` controls how many words each chunk contains; `overlap` controls how many words are shared between adjacent chunks to preserve context across boundaries.
+
+2. **Embedding** — Each chunk is embedded into a vector using either OpenAI or Sentence Transformers.
+
+3. **Retrieval** — When you run a query, it is embedded the same way and compared against all chunk embeddings. Only chunks that meet or exceed the `threshold` similarity score are returned.
+
+---
+
+## API Reference
+
+### `Nzacha(chunk_size, overlap, openai_api_key, threshold)`
+Initializes the context filter with the given configuration.
+
+### `nz.add_by_words(data: str)`
+Chunks the provided string dataset by word count and stores the embeddings internally. Must be called before querying.
+
+- `data` — Your full dataset as a **string**. Convert lists, dicts, DataFrames, or any other structure to a string first.
+
+---
+
+## Notes
+
+- Always pass data as a plain string. Use `str()`, `json.dumps()`, or `.to_string()` (for DataFrames) to convert before calling `add_by_words()`.
+- A lower `threshold` returns more (but less precise) chunks. A higher threshold is stricter.
+- Chunk `overlap` helps avoid losing context that falls on chunk boundaries — tune it based on your data's structure.
+
+---
+
+## Contributing
+
+Contributions are welcome! If you spot an area for improvement — whether it's a new chunking strategy, a better embedding backend, performance optimizations, or additional retrieval methods — feel free to open an issue or submit a pull request.
+
+Please make sure any changes are well-tested and clearly documented.
+
+---
+
+## License
+
+MIT

nzachapy-0.1.0/nzachapy/__init__.py

@@ -0,0 +1,4 @@
+from .core import Nzacha
+
+
+__all__ = ["Nzacha"]

nzachapy-0.1.0/nzachapy/core.py

@@ -0,0 +1,57 @@
+from .sementic import embed, match_embeddings
+
+class Nzacha:
+    def __init__(self,
+                 chunk_size = 200,
+                 overlap = 20,
+                 openai_api_key: str = None ,
+                 threshold = 0.6):
+        self.chunk_size = chunk_size
+        self.overlap = overlap
+        self.openai_api_key =openai_api_key
+        self.threshold = threshold
+
+        self.text_chunks = []
+        self.embeddings = []
+
+    def add_by_words(self, data: str):
+        data = data.split()
+
+        if self.overlap >= self.chunk_size:
+            raise ValueError("Overlap must be smaller than chunk size")
+        start = 0
+        while start < len(data):
+            end = start + self.chunk_size
+            chunk = data[start:end]
+
+            chunk_text = " ".join(chunk)
+
+            self.text_chunks.append(chunk_text)
+
+            embedding = embed(chunk_text, self.openai_api_key)
+            self.embeddings.append(embedding)
+
+            start += (self.chunk_size - self.overlap)
+
+        return self.text_chunks
+
+    def search(self, query: str):
+        query_embedding = embed(query, self.openai_api_key)
+
+        related = match_embeddings(self.embeddings, query_embedding, self.threshold)
+
+        related_data = []
+
+        for item in related:
+            index = item["index"]
+            related_data.append(self.text_chunks[index])
+
+
+        if related_data == []:
+            return "No strong semantic matches found. Consider lowering threshold."
+        else:
+            return " ".join(related_data)
+
+
+
+

nzachapy-0.1.0/nzachapy/sementic.py

@@ -0,0 +1,38 @@
+from sentence_transformers import SentenceTransformer, util
+import httpx
+from openai import OpenAI
+import torch
+from functools import lru_cache
+
+model = SentenceTransformer('all-MiniLM-L6-v2')
+
+@lru_cache(maxsize=5000)
+def embed(data, openai_api_key=None):
+    if openai_api_key:
+        client = OpenAI(api_key=openai_api_key, http_client=httpx.Client(timeout=None))
+
+        response = client.embeddings.create(
+            model='text-embedding-3-small',
+            input=data
+        )
+        return response.data[0].embedding
+
+
+    data_embedding = model.encode(data, convert_to_tensor=True).tolist()
+
+    return data_embedding
+
+def match_embeddings(data_embedding_list, query_embedding, threshold):
+    data_embeddings = torch.stack([torch.tensor(c) for c in data_embedding_list])
+
+    similarities = util.cos_sim(query_embedding, data_embeddings)[0]
+
+    related = [
+        {"index": i, "score": float(similarities[i])}
+        for i in range(len(data_embedding_list))
+        if similarities[i] >= threshold
+    ]
+
+    related.sort(key=lambda x: x["score"], reverse=True)
+
+    return related

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

@@ -0,0 +1,124 @@
+Metadata-Version: 2.4
+Name: nzachapy
+Version: 0.1.0
+Summary: Context filtering module that scans your data and returns only relevant portions based on a query.
+Author: Leonard Nwosu
+Project-URL: Homepage, https://github.com/Dblvcksheep/nzachapy
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy
+Requires-Dist: sentence-transformers
+Requires-Dist: openai
+Requires-Dist: httpx
+Dynamic: license-file
+
+# nzachapy
+
+> **Context Filtering for LLMs** — Scan your entire dataset and return only the portion relevant to your query.
+
+When working with large datasets and language models, stuffing everything into the context window is noisy and expensive. `nzachapy` solves this by chunking your data, embedding it semantically, and returning only the chunks most relevant to a given query — so your model sees signal, not noise.
+
+---
+
+## Installation
+
+```bash
+pip install nzachapy
+```
+
+---
+
+## Quick Start
+
+```python
+from nzachapy import Nzacha
+
+# Initialize the module
+nz = Nzacha()
+
+# Add your dataset (must be a string)
+nz.add_by_words(data)
+
+# Query for relevant context
+results = nz.query("your query here")
+```
+
+> ⚠️ **Important:** Your dataset must be converted to a string before passing it to `add_by_words()`.
+
+---
+
+## Configuration
+
+When initializing `Nzacha`, you can customize the following parameters. If left unset, the defaults are used.
+
+| Parameter | Default | Description |
+|---|---|---|
+| `chunk_size` | `200` | Number of words per chunk |
+| `overlap` | `20` | Number of overlapping words between consecutive chunks |
+| `openai_api_key` | `None` | OpenAI API key for semantic embeddings (optional) |
+| `threshold` | `0.6` | Minimum similarity score for a chunk to be returned |
+
+### Example with custom config
+
+```python
+nz = Nzacha(
+    chunk_size=150,
+    overlap=30,
+    openai_api_key="sk-...",
+    threshold=0.75
+)
+```
+
+---
+
+## Embedding Backends
+
+`nzachapy` supports two embedding strategies:
+
+- **OpenAI** — Provide your `openai_api_key` at initialization to use OpenAI's embedding models for higher-quality semantic search.
+- **Sentence Transformers** *(default)* — If no API key is provided, the module falls back to a local `sentence-transformers` model. No API key required.
+
+---
+
+## How It Works
+
+1. **Chunking** — `add_by_words(data)` splits your string dataset into overlapping word-based chunks. `chunk_size` controls how many words each chunk contains; `overlap` controls how many words are shared between adjacent chunks to preserve context across boundaries.
+
+2. **Embedding** — Each chunk is embedded into a vector using either OpenAI or Sentence Transformers.
+
+3. **Retrieval** — When you run a query, it is embedded the same way and compared against all chunk embeddings. Only chunks that meet or exceed the `threshold` similarity score are returned.
+
+---
+
+## API Reference
+
+### `Nzacha(chunk_size, overlap, openai_api_key, threshold)`
+Initializes the context filter with the given configuration.
+
+### `nz.add_by_words(data: str)`
+Chunks the provided string dataset by word count and stores the embeddings internally. Must be called before querying.
+
+- `data` — Your full dataset as a **string**. Convert lists, dicts, DataFrames, or any other structure to a string first.
+
+---
+
+## Notes
+
+- Always pass data as a plain string. Use `str()`, `json.dumps()`, or `.to_string()` (for DataFrames) to convert before calling `add_by_words()`.
+- A lower `threshold` returns more (but less precise) chunks. A higher threshold is stricter.
+- Chunk `overlap` helps avoid losing context that falls on chunk boundaries — tune it based on your data's structure.
+
+---
+
+## Contributing
+
+Contributions are welcome! If you spot an area for improvement — whether it's a new chunking strategy, a better embedding backend, performance optimizations, or additional retrieval methods — feel free to open an issue or submit a pull request.
+
+Please make sure any changes are well-tested and clearly documented.
+
+---
+
+## License
+
+MIT

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

@@ -0,0 +1,12 @@
+LICENSE
+README.md
+pyproject.toml
+nzachapy/__init__.py
+nzachapy/core.py
+nzachapy/sementic.py
+nzachapy.egg-info/PKG-INFO
+nzachapy.egg-info/SOURCES.txt
+nzachapy.egg-info/dependency_links.txt
+nzachapy.egg-info/requires.txt
+nzachapy.egg-info/top_level.txt
+tests/test.py

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

@@ -0,0 +1 @@
+

nzachapy-0.1.0/nzachapy.egg-info/requires.txt

@@ -0,0 +1,4 @@
+numpy
+sentence-transformers
+openai
+httpx

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

@@ -0,0 +1 @@
+nzachapy

nzachapy-0.1.0/pyproject.toml

@@ -0,0 +1,23 @@
+[build-system]
+requires = ["setuptools>=68", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "nzachapy"
+version = "0.1.0"
+description = "Context filtering module that scans your data and returns only relevant portions based on a query."
+readme = "README.md"
+requires-python = ">=3.8"
+authors = [
+    { name = "Leonard Nwosu" }
+]
+
+dependencies = [
+    "numpy",
+    "sentence-transformers",
+    "openai",
+    "httpx"
+]
+
+[project.urls]
+Homepage = "https://github.com/Dblvcksheep/nzachapy"

nzachapy-0.1.0/setup.cfg

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

nzachapy-0.1.0/tests/test.py

@@ -0,0 +1,58 @@
+from nzachapy import Nzacha
+
+
+
+
+data = '''The future without oil! For optimists, a pleasant picture: let’s call it Picture One. Shall we imagine it?
+
+There we are, driving around in our cars fueled by hydrogen, or methane, or solar, or something else we have yet to dream up. Goods from afar come to us by solar-and-sail-driven ship — the sails computerized to catch every whiff of air — or else by new versions of the airship, which can lift and carry a huge amount of freight with minimal pollution and no ear-slitting noise. Trains have made a comeback. So have bicycles, when it isn’t snowing; but maybe there won’t be any more winter.
+
+
+We’ve gone back to small-scale hydropower, using fish-friendly dams. We’re eating locally, and even growing organic vegetables on our erstwhile front lawns, watering them with greywater and rainwater, and with the water saved from using low-flush toilets, showers instead of baths, water-saving washing machines, and other appliances already on the market. We’re using low-draw lightbulbs — incandescents have been banned — and energy-efficient heating systems, including pellet stoves, radiant panels, and long underwear. Heat yourself, not the room is no longer a slogan for nutty eccentrics: it’s the way we all live now.
+
+
+
+Due to improved insulation and indoor-climate-enhancing practices, including heatproof blinds and awnings, air-conditioning systems are obsolete, so they no longer suck up huge amounts of power every summer. As for power, in addition to hydro, solar, geothermal, wave, and wind generation, and emissions-free coal plants, we’re using almost foolproof nuclear power. Even when there are accidents it isn’t all bad news, because instant wildlife refuges are created as Nature invades those high-radiation zones where Man now fears to tread. There’s said to be some remarkable wildlife and botany in the area surrounding Chernobyl.
+
+
+What will we wear? A lot of hemp clothing, I expect: hemp is a hardy fiber source with few pesticide requirements, and cotton will have proven too costly and destructive to grow. We might also be wearing a lot of recycled tinfoil — keeps the heat in — and garments made from the recycled plastic we’ve harvested from the island of it twice the size of Texas currently floating around in the Pacific Ocean. What will we eat, besides our front-lawn vegetables? That may be a problem — we’re coming to the end of cheap fish, and there are other shortages looming. Abundant animal protein in large hunks may have had its day. However, we’re an inventive species, and when push comes to shove we don’t have a lot of fastidiousness: being omnivores, we’ll eat anything as long as there’s ketchup. Looking on the bright side: obesity due to over-eating will no longer be a crisis, and diet plans will not only be free, but mandatory.
+
+That’s Picture One. I like it. It’s comforting. Under certain conditions, it might even come true. Sort of. More or less.
+
+
+Then there’s Picture Two. Suppose the future without oil arrives very quickly. Suppose a bad fairy waves his wand, and poof! Suddenly there’s no oil, anywhere, at all.
+
+Everything would immediately come to a halt. No cars, no planes; a few trains still running on hydroelectric, and some bicycles, but that wouldn’t take very many people very far. Food would cease to flow into the cities, water would cease to flow out of the taps. Within hours, panic would set in.
+
+
+The first result would be the disappearance of the word “we”: except in areas with exceptional organization and leadership, the word “I” would replace it, as the war of all against all sets in. There would be a run on the supermarkets, followed immediately by food riots and looting. There would also be a run on the banks — people would want their money out for black market purchasing, although all currencies would quickly lose value, replaced by bartering. In any case the banks would close: their electronic systems would shut down, and they’d run out of cash.
+
+
+Having looted and hoarded some food and filled their bathtubs with water, people would hunker down in their houses, creeping out into the backyards if they dared because their toilets would no longer flush. The lights would go out. Communication systems would break down. What next? Open a can of dog food, eat it, then eat the dog, then wait for the authorities to restore order. But the authorities — lacking transport — would be unable to do this.
+
+
+Other authorities would take over. These would at first be known as thugs and street gangs, then as warlords. They’d attack the barricaded houses, raping, pillaging and murdering. But soon even they would run out of stolen food. It wouldn’t take long — given starvation, festering garbage, multiplying rats, and putrefying corpses — for pandemic disease to break out. It will quickly become apparent that the present world population of six and a half billion people is not only dependent on oil, but was created by it: humanity has expanded to fill the space made possible to it by oil, and without that oil it would shrink with astounding rapidity. As for the costs to “the economy,” there won’t be any “economy.” Money will vanish: the only items of exchange will be food, water, and most likely — before everyone topples over — sex.
+
+
+Picture Two is extreme, and also unlikely, but it exposes the truth: we’re hooked on oil, and without it we can’t do much of anything. And since it’s bound to run out eventually, and since cheap oil is already a thing of the past, we ought to be investing a lot of time, effort, and money in ways to replace it.
+
+Unfortunately, like every other species on the planet, we’re conservative: we don’t change our ways unless necessity forces us. The early lungfish didn’t develop lungs because it wanted to be a land animal, but because it wanted to remain a fish even as the dry season drew down the water around it. We’re also self-interested: unless there are laws mandating conservation of energy, most won’t do it, because why make sacrifices if others don’t? The absence of fair and enforceable energy-use rules penalizes the conscientious while enriching the amoral. In business, the laws of competition mean that most corporations will extract maximum riches from available resources with not much thought to the consequences. Why expect any human being or institution to behave otherwise unless they can see clear benefits?
+
+
+Inaddition to Pictures One and Two, there’s Picture Three. In Picture Three, some countries plan for the future of diminished oil, some don’t. Those planning now include — not strangely — those that don’t have any, or don’t need any. Iceland generates over half its power from abundant geothermal sources: it will not suffer much from an oil dearth. Germany is rapidly converting, as are a number of other oil-poor European countries. They are preparing to weather the coming storm.
+
+
+Then there are the oil-rich countries. Of these, those who were poor in the past, who got rich quick, and who have no resources other than oil are investing the oil wealth they know to be temporary in technologies they hope will work for them when the oil runs out. But in countries that have oil, but that have other resources too, such foresight is lacking. It does exist in one form: as a Pentagon report of 2003 called “An Abrupt Climate Change Scenario and its Implications for United States National Security” put it, “Nations with the resources to do so may build virtual fortresses around their countries, preserving resources for themselves.” That’s already happening: the walls grow higher and stronger every day.
+
+
+But the long-term government planning needed to deal with diminishing oil within rich, mixed-resource countries is mostly lacking. Biofuel is largely delusional: the amount of oil required to make it is larger than the payout. Some oil companies are exploring the development of other energy sources, but by and large they’re simply lobbying against anything and anyone that might cause a decrease in consumption and thus impact on their profits. It’s gold-rush time, and oil is the gold, and short-term gain outweighs long-term pain, and madness is afoot, and anyone who wants to stop the rush is deemed an enemy.
+
+My own country, Canada, is an oil-rich country. A lot of the oil is in the Athabasca oil sands, where licenses to mine oil are sold to anyone with the cash, and where CO2 is being poured into the atmosphere, not only from the oil used as an end product, but also in the course of its manufacture. Also used in its manufacture is an enormous amount of water. The water mostly comes from the Athabasca River, which is fed by a glacier. But due to global warming, glaciers are melting fast. When they’re gone, no more water, and thus no more oil from oil sands. Maybe we’ll be saved — partially — by our own ineptness. But we’ll leave much destruction in our wake.
+
+'''
+query = "effect of cars on climate change"
+nz = Nzacha(threshold=0.3)
+
+nz.add_by_words(data)
+
+print(nz.search(query))