coffy 0.1.0__py3-none-any.whl

coffy/__init__.py

@@ -0,0 +1,2 @@
+# coffy/__init__.py
+# author: nsarathy

coffy/graph/__init__.py

@@ -0,0 +1,4 @@
+# coffy/graph/__init__.py
+# author: nsarathy
+
+from .graphdb_nx import GraphDB

coffy/graph/graphdb_nx.py

@@ -0,0 +1,99 @@
+import networkx as nx
+
+class GraphDB:
+    def __init__(self, directed=False):
+        self.g = nx.DiGraph() if directed else nx.Graph()
+
+    # Node operations
+    def add_node(self, node_id, **attrs):
+        self.g.add_node(node_id, **attrs)
+
+    def add_nodes(self, nodes):
+        for node in nodes:
+            self.add_node(node["id"], **{k: v for k, v in node.items() if k != "id"})
+
+    def get_node(self, node_id):
+        return self.g.nodes[node_id]
+
+    def remove_node(self, node_id):
+        self.g.remove_node(node_id)
+
+    # Relationship (edge) operations
+    def add_relationship(self, source, target, **attrs):
+        self.g.add_edge(source, target, **attrs)
+
+    def add_relationships(self, relationships):
+        for rel in relationships:
+            self.add_relationship(rel["source"], rel["target"],
+                                  **{k: v for k, v in rel.items() if k not in ["source", "target"]})
+
+    def get_relationship(self, source, target):
+        return self.g.get_edge_data(source, target)
+
+    def remove_relationship(self, source, target):
+        self.g.remove_edge(source, target)
+
+    # Basic queries
+    def neighbors(self, node_id):
+        return list(self.g.neighbors(node_id))
+
+    def degree(self, node_id):
+        return self.g.degree[node_id]
+
+    def has_node(self, node_id):
+        return self.g.has_node(node_id)
+
+    def has_relationship(self, u, v):
+        return self.g.has_edge(u, v)
+
+    # Advanced node search
+    def find_nodes(self, **conditions):
+        return [
+            {"id": n, **a} for n, a in self.g.nodes(data=True)
+            if self._match_conditions(a, conditions)
+        ]
+
+    def find_relationships(self, **conditions):
+        return [
+            {"source": u, "target": v, **a} for u, v, a in self.g.edges(data=True)
+            if self._match_conditions(a, conditions)
+        ]
+
+    def _match_conditions(self, attrs, conditions):
+        if not conditions:
+            return True
+        logic = conditions.pop("_logic", "and")
+        results = []
+
+        for key, expected in conditions.items():
+            actual = attrs.get(key)
+            if isinstance(expected, dict):
+                for op, val in expected.items():
+                    if op == "gt": results.append(actual > val)
+                    elif op == "lt": results.append(actual < val)
+                    elif op == "gte": results.append(actual >= val)
+                    elif op == "lte": results.append(actual <= val)
+                    elif op == "ne": results.append(actual != val)
+                    elif op == "eq": results.append(actual == val)
+                    else: results.append(False)
+            else:
+                results.append(actual == expected)
+
+        if logic == "or":
+            return any(results)
+        elif logic == "not":
+            return not all(results)
+        return all(results)
+
+    # Export
+    def nodes(self):
+        return [{"id": n, **a} for n, a in self.g.nodes(data=True)]
+
+    def relationships(self):
+        return [{"source": u, "target": v, **a} for u, v, a in self.g.edges(data=True)]
+
+    def to_dict(self):
+        return {
+            "nodes": self.nodes(),
+            "relationships": self.relationships()
+        }

coffy/nosql/__init__.py

@@ -0,0 +1,7 @@
+# coffy/nosql/__init__.py
+# author: nsarathy
+
+from .engine import CollectionManager
+
+def db(collection_name: str, path: str = None):
+    return CollectionManager(collection_name, path=path)

coffy/nosql/engine.py

@@ -0,0 +1,304 @@
+# coffy/nosql/engine.py
+# author: nsarathy
+
+import json
+import os
+import re
+
+class QueryBuilder:
+    def __init__(self, documents, all_collections=None):
+        self.documents = documents
+        self.filters = []
+        self.current_field = None
+        self.all_collections = all_collections or {}
+        self._lookup_done = False
+        self._lookup_results = None
+
+    def where(self, field):
+        self.current_field = field
+        return self
+
+    # Comparison
+    def eq(self, value): return self._add_filter(lambda d: d.get(self.current_field) == value)
+    def ne(self, value): return self._add_filter(lambda d: d.get(self.current_field) != value)
+    def gt(self, value):
+        return self._add_filter(
+            lambda d: isinstance(d.get(self.current_field), (int, float)) and d.get(self.current_field) > value
+        )
+
+    def gte(self, value):
+        return self._add_filter(
+            lambda d: isinstance(d.get(self.current_field), (int, float)) and d.get(self.current_field) >= value
+        )
+
+    def lt(self, value):
+        return self._add_filter(
+            lambda d: isinstance(d.get(self.current_field), (int, float)) and d.get(self.current_field) < value
+        )
+
+    def lte(self, value):
+        return self._add_filter(
+            lambda d: isinstance(d.get(self.current_field), (int, float)) and d.get(self.current_field) <= value
+        )
+
+    def in_(self, values):
+        return self._add_filter(
+            lambda d: d.get(self.current_field) in values
+        )
+
+    def nin(self, values):
+        return self._add_filter(
+            lambda d: d.get(self.current_field) not in values
+        )
+
+    def matches(self, regex): return self._add_filter(lambda d: re.search(regex, str(d.get(self.current_field))))
+    
+    def exists(self): return self._add_filter(lambda d: self.current_field in d)
+
+    # Logic grouping
+    def _and(self, *fns):
+        for fn in fns:
+            sub = QueryBuilder(self.documents, self.all_collections)
+            fn(sub)
+            self.filters.append(lambda d, fs=sub.filters: all(f(d) for f in fs))
+        return self
+
+    def _not(self, *fns):
+        for fn in fns:
+            sub = QueryBuilder(self.documents, self.all_collections)
+            fn(sub)
+            self.filters.append(lambda d, fs=sub.filters: not all(f(d) for f in fs))
+        return self
+
+    def _or(self, *fns):
+        chains = []
+        for fn in fns:
+            sub = QueryBuilder(self.documents, self.all_collections)
+            fn(sub)
+            chains.append(sub.filters)
+        self.filters.append(lambda d: any(all(f(d) for f in chain) for chain in chains))
+        return self
+
+    # Add filter
+    def _add_filter(self, fn):
+        negate = getattr(self, "_negate", False)
+        self._negate = False
+        self.filters.append(lambda d: not fn(d) if negate else fn(d))
+        return self
+
+    # Core execution
+    def run(self):
+        results = [doc for doc in self.documents if all(f(doc) for f in self.filters)]
+        if self._lookup_done:
+            results = self._lookup_results
+        return DocList(results)
+
+    def update(self, changes):
+        count = 0
+        for doc in self.documents:
+            if all(f(doc) for f in self.filters):
+                doc.update(changes)
+                count += 1
+        return {"updated": count}
+
+    def delete(self):
+        before = len(self.documents)
+        self.documents[:] = [doc for doc in self.documents if not all(f(doc) for f in self.filters)]
+        return {"deleted": before - len(self.documents)}
+
+    def replace(self, new_doc):
+        replaced = 0
+        for i, doc in enumerate(self.documents):
+            if all(f(doc) for f in self.filters):
+                self.documents[i] = new_doc
+                replaced += 1
+        return {"replaced": replaced}
+
+    def count(self): return len(self.run())
+    def first(self): return next(iter(self.run()), None)
+
+    # Aggregates
+    def sum(self, field):
+        return sum(doc.get(field, 0) for doc in self.run() if isinstance(doc.get(field), (int, float)))
+
+    def avg(self, field):
+        values = [doc.get(field) for doc in self.run() if isinstance(doc.get(field), (int, float))]
+        return sum(values) / len(values) if values else 0
+
+    def min(self, field):
+        values = [doc.get(field) for doc in self.run() if isinstance(doc.get(field), (int, float))]
+        return min(values) if values else None
+
+    def max(self, field):
+        values = [doc.get(field) for doc in self.run() if isinstance(doc.get(field), (int, float))]
+        return max(values) if values else None
+
+    # Lookup
+    def lookup(self, foreign_collection_name, local_key, foreign_key, as_field):
+        foreign_docs = self.all_collections.get(foreign_collection_name, [])
+        fk_map = {doc[foreign_key]: doc for doc in foreign_docs}
+        enriched = []
+        for doc in self.run():
+            joined = fk_map.get(doc.get(local_key))
+            if joined:
+                doc = dict(doc)  # copy
+                doc[as_field] = joined
+                enriched.append(doc)
+        self._lookup_done = True
+        self._lookup_results = enriched
+        return self
+
+    # Merge
+    def merge(self, fn):
+        docs = self._lookup_results if self._lookup_done else self.run()
+        merged = []
+        for doc in docs:
+            new_doc = dict(doc)
+            new_doc.update(fn(doc))
+            merged.append(new_doc)
+        self._lookup_done = True
+        self._lookup_results = merged
+        return self
+
+
+
+_collection_registry = {}
+
+class CollectionManager:
+    DEFAULT_DIR = os.path.join(os.getcwd(), "nosql_data")
+
+    def __init__(self, name: str, path: str = None):
+        self.name = name
+        self.in_memory = False
+
+        if path:
+            self.path = path
+        else:
+            os.makedirs(self.DEFAULT_DIR, exist_ok=True)
+            self.path = os.path.join(self.DEFAULT_DIR, f"{name}.json")
+            self.in_memory = True if name == ":memory:" else False
+
+        self.documents = []
+        self._load()
+        _collection_registry[name] = self.documents
+
+    def _load(self):
+        if self.in_memory:
+            self.documents = []
+        else:
+            try:
+                with open(self.path, 'r', encoding='utf-8') as f:
+                    self.documents = json.load(f)
+            except FileNotFoundError:
+                self.documents = []
+
+    def _save(self):
+        if not self.in_memory:
+            with open(self.path, 'w', encoding='utf-8') as f:
+                json.dump(self.documents, f, indent=4)
+
+    def add(self, document: dict):
+        self.documents.append(document)
+        self._save()
+        return {"inserted": 1}
+
+    def add_many(self, docs: list[dict]):
+        self.documents.extend(docs)
+        self._save()
+        return {"inserted": len(docs)}
+
+    def where(self, field):
+        return QueryBuilder(self.documents, all_collections=_collection_registry).where(field)
+    
+    def match_any(self, *conditions):
+        q = QueryBuilder(self.documents, all_collections=_collection_registry)
+        return q._or(*conditions)
+
+    def match_all(self, *conditions):
+        q = QueryBuilder(self.documents, all_collections=_collection_registry)
+        return q._and(*conditions)
+
+    def not_any(self, *conditions):
+        q = QueryBuilder(self.documents, all_collections=_collection_registry)
+        return q._not(lambda nq: nq._or(*conditions))
+    
+    def lookup(self, *args, **kwargs):
+        return QueryBuilder(self.documents, all_collections=_collection_registry).lookup(*args, **kwargs)
+
+    def merge(self, *args, **kwargs):
+        return QueryBuilder(self.documents, all_collections=_collection_registry).merge(*args, **kwargs)
+
+    def sum(self, field):
+        return QueryBuilder(self.documents).sum(field)
+
+    def avg(self, field):
+        return QueryBuilder(self.documents).avg(field)
+
+    def min(self, field):
+        return QueryBuilder(self.documents).min(field)
+
+    def max(self, field):
+        return QueryBuilder(self.documents).max(field)
+
+    def count(self):
+        return QueryBuilder(self.documents).count()
+
+    def first(self):
+        return QueryBuilder(self.documents).first()
+
+    def clear(self):
+        count = len(self.documents)
+        self.documents = []
+        self._save()
+        return {"cleared": count}
+
+    def export(self, path):
+        with open(path, 'w', encoding='utf-8') as f:
+            json.dump(self.documents, f, indent=4)
+
+    def import_(self, path):
+        with open(path, 'r', encoding='utf-8') as f:
+            self.documents = json.load(f)
+        self._save()
+
+    def all(self): return self.documents
+    def count(self): return len(self.documents)
+
+    def save(self, path: str):
+        with open(path, 'w', encoding='utf-8') as f:
+            json.dump(self.documents, f, indent=4)
+    
+    def all_docs(self):
+        return self.documents
+
+class DocList:
+    def __init__(self, docs: list[dict]):
+        self._docs = docs
+
+    def __iter__(self):
+        return iter(self._docs)
+
+    def __getitem__(self, index):
+        return self._docs[index]
+
+    def __len__(self):
+        return len(self._docs)
+
+    def __repr__(self):
+        if not self._docs:
+            return "<empty result>"
+        keys = list(self._docs[0].keys())
+        header = " | ".join(keys)
+        line = "-+-".join("-" * len(k) for k in keys)
+        rows = []
+        for doc in self._docs:
+            row = " | ".join(str(doc.get(k, "")) for k in keys)
+            rows.append(row)
+        return f"{header}\n{line}\n" + "\n".join(rows)
+
+    def to_json(self, path: str):
+        with open(path, "w", encoding="utf-8") as f:
+            json.dump(self._docs, f, indent=4)
+
+    def as_list(self):
+        return self._docs

coffy/sql/__init__.py

@@ -0,0 +1,10 @@
+# coffy/sql/__init__.py
+# author: nsarathy
+
+from .engine import execute_query, initialize
+
+def init(path: str = None):
+    initialize(path)
+
+def query(sql: str):
+    return execute_query(sql)

coffy/sql/engine.py

@@ -0,0 +1,33 @@
+# coffy/sql/engine.py
+# author: nsarathy
+
+import sqlite3
+from .sqldict import SQLDict
+
+# Internal connection state
+_connection = None
+_cursor = None
+
+def initialize(db_path=None):
+    """Initialize the database connection."""
+    global _connection, _cursor
+    if _connection:
+        return  # already initialized
+    _connection = sqlite3.connect(db_path or ":memory:") # Uses in-memory DB if no path provided
+    _cursor = _connection.cursor()
+
+def execute_query(sql: str):
+    if _connection is None:
+        initialize()  # uses in-memory if not initialized
+
+    try:
+        _cursor.execute(sql)
+        if sql.strip().lower().startswith("select"):
+            columns = [desc[0] for desc in _cursor.description]
+            rows = _cursor.fetchall()
+            return SQLDict([dict(zip(columns, row)) for row in rows])
+        else:
+            _connection.commit()
+            return {"status": "success", "rows_affected": _cursor.rowcount}
+    except Exception as e:
+        return {"status": "error", "message": str(e)}

coffy/sql/sqldict.py

@@ -0,0 +1,58 @@
+# coffy/sql/sqldict.py
+# author: nsarathy
+
+from collections.abc import Sequence
+import csv
+import json
+
+class SQLDict(Sequence):
+    def __init__(self, data):
+        self._data = data if isinstance(data, list) else [data]
+
+    def __getitem__(self, index):
+        return self._data[index]
+
+    def __len__(self):
+        return len(self._data)
+
+    def __repr__(self):
+        if not self._data:
+            return "<empty result>"
+
+        # Get all column names
+        columns = list(self._data[0].keys())
+        col_widths = {col: max(len(col), *(len(str(row[col])) for row in self._data)) for col in columns}
+
+        # Header
+        header = " | ".join(f"{col:<{col_widths[col]}}" for col in columns)
+        line = "-+-".join('-' * col_widths[col] for col in columns)
+
+        # Rows
+        rows = []
+        for row in self._data:
+            row_str = " | ".join(f"{str(row[col]):<{col_widths[col]}}" for col in columns)
+            rows.append(row_str)
+
+        return f"{header}\n{line}\n" + "\n".join(rows)
+
+    def as_list(self):
+        """Access raw list of dicts."""
+        return self._data
+    
+    def to_csv(self, path: str):
+        """Write result to a CSV file."""
+        if not self._data:
+            raise ValueError("No data to write.")
+        
+        with open(path, mode='w', newline='', encoding='utf-8') as file:
+            writer = csv.DictWriter(file, fieldnames=self._data[0].keys())
+            writer.writeheader()
+            writer.writerows(self._data)
+    
+    def to_json(self, path: str):
+        """Write result to a JSON file."""
+        if not self._data:
+            raise ValueError("No data to write.")
+        
+        with open(path, mode='w', encoding='utf-8') as file:
+            json.dump(self._data, file, indent=4)

coffy-0.1.0.dist-info/METADATA

@@ -0,0 +1,106 @@
+Metadata-Version: 2.4
+Name: coffy
+Version: 0.1.0
+Summary: Lightweight local NoSQL, SQL, and Graph embedded database engine
+Author: nsarathy
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: networkx>=3.0
+Dynamic: author
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: license-file
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+# ☕ Coffy
+
+**Coffy** is a lightweight embedded database engine for Python, designed for local-first apps, scripts, and tools. It includes:
+
+- `coffy.nosql`: A simple JSON-backed NoSQL engine with a fluent, chainable query interface  
+- `coffy.sql`: A minimal wrapper over SQLite for executing raw SQL with clean tabular results  
+- `coffy.graph`: An in-memory graph engine built on `networkx` with advanced filtering and logic-based querying
+
+No dependencies (except `networkx`). No boilerplate. Just data.
+
+---
+
+## 🔧 Install
+
+```bash
+pip install coffy
+```
+
+---
+
+## 📂 Modules
+
+### `coffy.nosql`
+
+- JSON-based collections with fluent `.where().eq().gt()...` query chaining  
+- Joins, updates, filters, aggregation, export/import  
+- All data saved to human-readable `.json` files  
+
+📄 [NoSQL Documentation →](./NOSQL_DOCS.md)
+
+---
+
+### `coffy.sql`
+
+- SQLite-backed engine with raw SQL query support  
+- Outputs as readable tables or exportable lists  
+- Uses in-memory DB by default, or file-based if initialized with a path  
+
+📄 [SQL Documentation →](./SQL_DOCS.md)
+
+---
+
+### `coffy.graph`
+
+- Wrapper around `networkx` with simplified node/relationship API  
+- Query nodes and relationships using filters like `gt`, `lt`, `eq`, `or`, `not`  
+- Returns clean structured output, easy to extend  
+
+📄 [Graph Documentation →](./GRAPH_DOCS.md)
+
+---
+
+## 🧪 Example
+
+```python
+from coffy.nosql import db
+
+users = db("users", path="users.json")
+users.add({"id": 1, "name": "Neel"})
+print(users.where("name").eq("Neel").first())
+```
+
+```python
+from coffy.sql import init, query
+
+init("app.db")
+query("CREATE TABLE test (id INT, name TEXT)")
+query("INSERT INTO test VALUES (1, 'Neel')")
+print(query("SELECT * FROM test"))
+```
+
+```python
+from coffy.graph import GraphDB
+
+g = GraphDB(directed=True)
+g.add_nodes([{"id": 1, "name": "Neel"}, {"id": 2, "name": "Tanaya"}])
+g.add_relationships([{"source": 1, "target": 2, "type": "friend"}])
+print(g.find_relationships(type="friend"))
+```
+
+---
+
+## 📄 License
+
+MIT © 2025 nsarathy

coffy-0.1.0.dist-info/RECORD

@@ -0,0 +1,28 @@
+coffy/__init__.py,sha256=Q5FwcCZtemm41gSD-n-t9zAipeh5XV7JuoBzEHze7J8,39
+coffy/__pycache__/__init__.cpython-311.pyc,sha256=Mf7ImWR3gBHSLuRr-Wf__3OsjKGpdH8D5T2qm-em5AM,150
+coffy/__pycache__/__init__.cpython-312.pyc,sha256=n_nvLEknScZM-FT6aNmDlpZGQd_ZHB3p_zRJirbI_Ic,146
+coffy/graph/__init__.py,sha256=Z0cIgmxre3YgwBrstubB1PTElP5uatz3ZOEIuW9EwY4,80
+coffy/graph/graphdb_nx.py,sha256=v-36PXkROACXqOANWGyoKt29TfNTkTS7wNq9EjA7OJg,3242
+coffy/graph/__pycache__/__init__.cpython-312.pyc,sha256=GCuchZzMG77ILVDNh1wX5eerxwQlrnm0VGNAqjGITXg,199
+coffy/graph/__pycache__/graphdb_nx.cpython-312.pyc,sha256=tPP_42IXY_lwkqWU0i3Ab58HtQxJCNDkk2mROmllKCM,6632
+coffy/nosql/__init__.py,sha256=HN9UfUd9pooB7udUxNn3EAttEjGG394fECOXDb6SH60,197
+coffy/nosql/engine.py,sha256=-rXYu4Ps6P_6C8nIbEpGRuDeJgAi33_FebGZNlM4jsg,10103
+coffy/nosql/__pycache__/__init__.cpython-311.pyc,sha256=0dDD3adswuWrOOUVE_2KjO80zmOHkPAjW7pxMg4fukk,463
+coffy/nosql/__pycache__/__init__.cpython-312.pyc,sha256=NdU26hkvPHawUktm4TUoEirspFgWDMaixaQV7cGAYIc,409
+coffy/nosql/__pycache__/engine.cpython-311.pyc,sha256=lJm3ZWQbStmBV1p9pmXdrIBcf2PMPM0SGozUEHdInA8,27471
+coffy/nosql/__pycache__/engine.cpython-312.pyc,sha256=YCxgeof-6PE5SlrmDLyYLu8967UXN42vpciaUAM5XCg,24241
+coffy/sql/__init__.py,sha256=dXoCW3Qyk3WoYl-y2gHCc8YK6dAUt0Eaqhtk3PEDHMQ,202
+coffy/sql/engine.py,sha256=q9A7zvg9JANpWAFvbw8wfGY5BTkvObpM3eoQ6dZYu_8,1065
+coffy/sql/sqldict.py,sha256=0IxlCz1hi1zj5Q4_8If9YXwQBZGczpMir7PMXBOxbjs,1837
+coffy/sql/__pycache__/__init__.cpython-311.pyc,sha256=6kqiDVzq_X9yFEMupVrLUCQL3JinwHVxDFXJSrme3pI,628
+coffy/sql/__pycache__/__init__.cpython-312.pyc,sha256=jB-bTlCkiV0dNzISmDoBcqf861iQF6q2O14ylDO39yw,535
+coffy/sql/__pycache__/engine.cpython-311.pyc,sha256=IbSKkWjikTnkXhGDgqJHo2n49SREzRULeUXQfAcFt_Q,2239
+coffy/sql/__pycache__/engine.cpython-312.pyc,sha256=fKlvycKKYZOslQd6SDHexrWV_NDcPoqNQWoiS8do49w,1746
+coffy/sql/__pycache__/io.cpython-312.pyc,sha256=TPkeJ3qUE_ZcvcykGIf-Yyc0__5FZKB1J95_2yTFrXY,2517
+coffy/sql/__pycache__/sqldict.cpython-311.pyc,sha256=jJQDFH9ULzi2ay4pyXXye-W_PSjxuT_ULb20CdL8Ec0,5131
+coffy/sql/__pycache__/sqldict.cpython-312.pyc,sha256=T4P9qMjH7dHqDTp3gzZQbhpdpfgdopmC3ccm8O8gooc,4339
+coffy-0.1.0.dist-info/licenses/LICENSE,sha256=iRyxG6b7B-JPKuOcS7w5lDhrL0AD9fFSDUh6-KMKDO8,1068
+coffy-0.1.0.dist-info/METADATA,sha256=swg1zpj6plEIbtzR5O7p6CzGxR4P5_3nVk1WSRKkyo4,2725
+coffy-0.1.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+coffy-0.1.0.dist-info/top_level.txt,sha256=J1zGvXA_bfET3PsE4-qbFrtFMIN3bJNxBRMHKk6YIv0,6
+coffy-0.1.0.dist-info/RECORD,,

coffy-0.1.0.dist-info/WHEEL

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

coffy-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,7 @@
+Copyright 2025 Neelesh Sarathy
+
+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.

coffy-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+coffy