topiclayers 0.2.0__py3-none-any.whl

topiclayers/manifest.py

@@ -0,0 +1,88 @@
+"""Run manifest: reproducibility metadata for each pipeline run."""
+
+from __future__ import annotations
+
+import json
+from dataclasses import dataclass, asdict
+from pathlib import Path
+from typing import Optional
+
+
+@dataclass
+class RunManifest:
+    topiclayers_version: str
+    git_hash: Optional[str]
+    python_version: str
+    library_versions: dict
+    params: dict
+    input_hash: str
+    row_counts: dict
+    dropped_edges: int
+    topic_distribution: dict
+    status: str
+    timestamp: str
+
+    @classmethod
+    def create(cls, params, row_counts, topic_dist, dropped, status):
+        import hashlib
+        import subprocess
+        import sys
+        from datetime import datetime, timezone
+
+        import topiclayers
+
+        git_hash = None
+        try:
+            result = subprocess.run(
+                ["git", "rev-parse", "HEAD"],
+                capture_output=True, text=True, timeout=5,
+            )
+            if result.returncode == 0:
+                git_hash = result.stdout.strip()
+        except Exception:
+            pass
+
+        library_versions = _gather_versions()
+
+        params_serialized = json.dumps(params, sort_keys=True, default=str)
+        input_hash = hashlib.sha256(params_serialized.encode()).hexdigest()[:16]
+
+        return cls(
+            topiclayers_version=topiclayers.__version__,
+            git_hash=git_hash,
+            python_version=sys.version.split()[0],
+            library_versions=library_versions,
+            params=params,
+            input_hash=input_hash,
+            row_counts=row_counts,
+            dropped_edges=dropped,
+            topic_distribution=topic_dist,
+            status=status,
+            timestamp=datetime.now(timezone.utc).isoformat(),
+        )
+
+    def write(self, path: Path) -> None:
+        with open(path, "w") as f:
+            json.dump(asdict(self), f, indent=2, default=str)
+
+    @classmethod
+    def load(cls, path: Path) -> "RunManifest":
+        with open(path) as f:
+            data = json.load(f)
+        return cls(**data)
+
+
+def _gather_versions() -> dict:
+    deps = [
+        "numpy", "pandas", "networkx", "scipy",
+        "bertopic", "umap", "sklearn", "sentence_transformers",
+        "openai", "qdrant_client",
+    ]
+    versions: dict = {}
+    for pkg in deps:
+        try:
+            mod = __import__(pkg)
+            versions[pkg] = getattr(mod, "__version__", "unknown")
+        except ImportError:
+            versions[pkg] = "not installed"
+    return versions

topiclayers/schema.py

@@ -0,0 +1,27 @@
+"""Generic post schema: Post dataclass and InteractionType enum."""
+
+from __future__ import annotations
+from dataclasses import dataclass, field
+from enum import Enum
+from typing import Optional
+
+
+class InteractionType(str, Enum):
+    ORIGINAL = "original"
+    REPOST = "repost"
+    QUOTE = "quote"
+    REPLY = "reply"
+
+
+@dataclass
+class Post:
+    post_id: str
+    user_id: str
+    text: str
+    created_at: Optional[str] = None
+    lang: Optional[str] = None
+    interaction_type: Optional[InteractionType] = None
+    target_post_id: Optional[str] = None
+    target_user_id: Optional[str] = None
+    mentions: list[str] = field(default_factory=list)
+    extra: dict = field(default_factory=dict)

topiclayers/status.py

@@ -0,0 +1,214 @@
+"""Run status: live stage tracking and ETA for long-running pipeline runs."""
+
+from __future__ import annotations
+
+import json
+import os
+import threading
+import time
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Optional
+
+STAGES = ["load", "data", "embed", "topic_model", "label", "network", "manifest"]
+_STATUS_FILE = "run_status.json"
+_TIMINGS_FILE = "stage_timings.json"
+_MIN_UPDATE_INTERVAL = 1.0
+_HEARTBEAT_INTERVAL = 5.0
+
+
+class RunStatus:
+    def __init__(self, output_dir: Path, name: str):
+        self.output_dir = Path(output_dir)
+        self.name = name
+        self.path = self.output_dir / _STATUS_FILE
+        self.timings_path = self.output_dir / "cache" / _TIMINGS_FILE
+        self.current_stage: Optional[str] = None
+        self.stage_index: Optional[int] = None
+        self.stage_total: Optional[int] = None
+        self.processed: Optional[int] = None
+        self.started_at = datetime.now(timezone.utc)
+        self.stage_started_at: Optional[datetime] = None
+        self._last_write = 0.0
+        self._stop_heartbeat = threading.Event()
+        self._heartbeat_thread: Optional[threading.Thread] = None
+
+    def start(self) -> None:
+        self._start_heartbeat()
+        self._write(status="running")
+
+    def _start_heartbeat(self) -> None:
+        # keeps stage_elapsed_seconds fresh during opaque stages (e.g. UMAP +
+        # HDBSCAN) that never call update()
+        def beat():
+            while not self._stop_heartbeat.wait(_HEARTBEAT_INTERVAL):
+                if self.current_stage is not None:
+                    self._write(status="running", force=True)
+
+        self._heartbeat_thread = threading.Thread(target=beat, daemon=True)
+        self._heartbeat_thread.start()
+
+    def stage(self, name: str, total: Optional[int] = None) -> None:
+        now = datetime.now(timezone.utc)
+        if self.current_stage is not None and self.stage_started_at is not None:
+            duration = (now - self.stage_started_at).total_seconds()
+            self._record_timing(self.current_stage, duration)
+        self.current_stage = name
+        self.stage_index = STAGES.index(name) if name in STAGES else None
+        self.stage_total = total
+        self.processed = 0
+        self.stage_started_at = now
+        self._write(status="running", force=True)
+
+    def update(self, processed: int, total: Optional[int] = None) -> None:
+        self.processed = processed
+        if total is not None:
+            self.stage_total = total
+        self._write(status="running", throttle=True)
+
+    def flush(self) -> None:
+        self._write(status="running", force=True)
+
+    def finish(self, status: str = "success") -> None:
+        self._stop_heartbeat.set()
+        if self.current_stage is not None and self.stage_started_at is not None:
+            duration = (datetime.now(timezone.utc) - self.stage_started_at).total_seconds()
+            self._record_timing(self.current_stage, duration)
+        self._write(status=status, force=True)
+
+    def _eta_seconds(self) -> Optional[float]:
+        if (
+            self.processed is None
+            or self.stage_total is None
+            or self.stage_started_at is None
+            or self.processed <= 0
+            or self.stage_total <= self.processed
+        ):
+            return None
+        elapsed = (datetime.now(timezone.utc) - self.stage_started_at).total_seconds()
+        if elapsed <= 0:
+            return None
+        rate = self.processed / elapsed
+        return (self.stage_total - self.processed) / rate
+
+    def _write(self, status: str, force: bool = False, throttle: bool = False) -> None:
+        now_monotonic = time.monotonic()
+        if throttle and not force:
+            if now_monotonic - self._last_write < _MIN_UPDATE_INTERVAL:
+                return
+        self._last_write = now_monotonic
+
+        now = datetime.now(timezone.utc)
+        payload = {
+            "name": self.name,
+            "status": status,
+            "stages": STAGES,
+            "current_stage": self.current_stage,
+            "stage_index": self.stage_index,
+            "stage_started_at": self.stage_started_at.isoformat() if self.stage_started_at else None,
+            "stage_elapsed_seconds": round((now - self.stage_started_at).total_seconds(), 2) if self.stage_started_at else None,
+            "total_elapsed_seconds": round((now - self.started_at).total_seconds(), 2),
+            "processed": self.processed,
+            "total": self.stage_total,
+            "eta_seconds": round(self._eta_seconds(), 2) if self._eta_seconds() is not None else None,
+            "updated_at": now.isoformat(),
+        }
+        self.output_dir.mkdir(parents=True, exist_ok=True)
+        tmp = self.path.with_suffix(f".tmp{threading.get_ident()}")
+        with open(tmp, "w") as f:
+            json.dump(payload, f, indent=2)
+        os.replace(tmp, self.path)
+
+    def _record_timing(self, stage: str, duration: float) -> None:
+        self.timings_path.parent.mkdir(parents=True, exist_ok=True)
+        records: list[dict] = []
+        if self.timings_path.exists():
+            try:
+                with open(self.timings_path) as f:
+                    records = json.load(f)
+            except Exception:
+                records = []
+        records.append({
+            "stage": stage,
+            "duration_seconds": round(duration, 2),
+            "timestamp": datetime.now(timezone.utc).isoformat(),
+        })
+        tmp = self.timings_path.with_suffix(".tmp")
+        with open(tmp, "w") as f:
+            json.dump(records, f, indent=2)
+        os.replace(tmp, self.timings_path)
+
+
+def load_status(path: Path) -> dict:
+    with open(path) as f:
+        return json.load(f)
+
+
+def historical_eta(timings_path: Path, stage: str, last_n: int = 3) -> Optional[float]:
+    if not timings_path.exists():
+        return None
+    try:
+        with open(timings_path) as f:
+            records = json.load(f)
+    except Exception:
+        return None
+    durations = sorted(r["duration_seconds"] for r in records if r.get("stage") == stage)
+    if not durations:
+        return None
+    return durations[len(durations) // 2]
+
+
+def format_seconds(seconds: Optional[float]) -> str:
+    if seconds is None:
+        return "unknown"
+    seconds = int(round(seconds))
+    if seconds < 60:
+        return f"{seconds}s"
+    if seconds < 3600:
+        return f"{seconds // 60}m {seconds % 60:02d}s"
+    return f"{seconds // 3600}h {(seconds % 3600) // 60:02d}m"
+
+
+def print_status(output_dir: Path) -> int:
+    path = output_dir / _STATUS_FILE
+    if not path.exists():
+        print(f"No run_status.json found in {output_dir}.")
+        print("Either no run has started there, or the config pointed to a different output_dir.")
+        return 1
+
+    data = load_status(path)
+    status = data.get("status", "unknown")
+    stage = data.get("current_stage")
+    idx = data.get("stage_index")
+    n_stages = len(data.get("stages", STAGES))
+
+    if idx is not None and stage:
+        print(f"Stage {idx + 1}/{n_stages}: {stage}")
+    elif stage:
+        print(f"Stage: {stage}")
+    print(f"Status: {status}")
+    print(f"Run: {data.get('name')}")
+
+    if status == "running":
+        total = data.get("total")
+        processed = data.get("processed")
+        if total:
+            pct = 100 * processed / total if processed is not None else 0
+            print(f"Progress: {processed}/{total} ({pct:.0f}%)")
+        stage_elapsed = data.get("stage_elapsed_seconds")
+        if stage_elapsed is not None:
+            print(f"Stage elapsed: {format_seconds(stage_elapsed)}")
+        eta = data.get("eta_seconds")
+        if eta is not None:
+            print(f"Stage ETA: ~{format_seconds(eta)}")
+        else:
+            hist = historical_eta(output_dir / "cache" / _TIMINGS_FILE, stage)
+            if hist is not None:
+                print(f"No live ETA for this stage; past runs took ~{format_seconds(hist)} (median).")
+            else:
+                print("No live ETA for this stage (no per-item counter, no past runs yet).")
+        print(f"Total elapsed: {format_seconds(data.get('total_elapsed_seconds'))}")
+    elif status in ("success", "failed"):
+        print(f"Total elapsed: {format_seconds(data.get('total_elapsed_seconds'))}")
+        print(f"Updated: {data.get('updated_at')}")
+    return 0

topiclayers/support/__init__.py

@@ -0,0 +1 @@
+"""Shared small helpers: cache keys and reproducibility seeds."""

topiclayers/support/cache.py

@@ -0,0 +1,11 @@
+from __future__ import annotations
+
+import hashlib
+import json
+
+
+def cache_key(*parts: str) -> str:
+    h = hashlib.sha256()
+    for p in parts:
+        h.update(json.dumps(p, sort_keys=True).encode())
+    return h.hexdigest()[:16]

topiclayers/support/repro.py

@@ -0,0 +1,16 @@
+from __future__ import annotations
+
+
+def set_global_seed(seed: int) -> None:
+    import random
+
+    import numpy as np
+
+    random.seed(seed)
+    np.random.seed(seed)
+    try:
+        import torch
+
+        torch.manual_seed(seed)
+    except ImportError:
+        pass

topiclayers-0.2.0.dist-info/METADATA

@@ -0,0 +1,201 @@
+Metadata-Version: 2.4
+Name: topiclayers
+Version: 0.2.0
+Summary: From any collection of posts to topical multilayer networks — hardened and social-scientist-friendly
+License: MIT
+License-File: LICENSE
+Keywords: topic-modeling,network-analysis,social-science,polarisation
+Author: alessiogandelli
+Author-email: alessiogandelli99@gmail.com
+Requires-Python: >=3.12,<3.13
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Provides-Extra: labeling
+Requires-Dist: bertopic (>=0.17.4,<0.18.0)
+Requires-Dist: igraph (>=0.11.4)
+Requires-Dist: jsonlines (>=4.0.0,<5.0.0)
+Requires-Dist: litellm (>=1.40) ; extra == "labeling"
+Requires-Dist: networkx (>=3.6,<4.0)
+Requires-Dist: numpy (>=1.26,<3)
+Requires-Dist: openai (>=3.0.0,<4.0.0)
+Requires-Dist: pandas (>=2.2,<4)
+Requires-Dist: python-dotenv (>=1.0.1,<2.0.0)
+Requires-Dist: pyyaml (>=6.0,<7.0)
+Requires-Dist: qdrant-client (>=1.19.0,<2.0.0)
+Requires-Dist: scikit-learn (>=1.5)
+Requires-Dist: sentence-transformers (>=6.0.0,<7.0.0)
+Requires-Dist: umap-learn (>=0.5.12,<0.6.0)
+Requires-Dist: uunet (>=2.1.1,<3.0.0)
+Project-URL: Changelog, https://github.com/alessiogandelli/topiclayers/blob/main/CHANGELOG.md
+Project-URL: Issues, https://github.com/alessiogandelli/topiclayers/issues
+Project-URL: Repository, https://github.com/alessiogandelli/topiclayers
+Description-Content-Type: text/markdown
+
+# topiclayers
+
+> From posts to topical multilayer networks — hardened and social-scientist-friendly.
+
+## Quickstart
+
+```bash
+# Requires Python 3.12
+pip install topiclayers
+topiclayers run examples/generic.yml
+```
+
+That's it. You get a GML network file in `./out/generic_toy/networks/`.
+
+## What does it do?
+
+1. **Loads** your posts (Twitter JSONL, CSV, Parquet).
+2. **Cleans** text (removes URLs, @mentions, newlines).
+3. **Models topics** using BERTopic with SentenceTransformer embeddings.
+4. **Labels topics** with an LLM (local via Ollama by default) and propagates topic labels through retweet chains.
+5. **Builds networks**: single-layer retweet, multilayer per-topic, and bipartite temporal-text networks.
+
+## Minimal config
+
+Save this as `my_config.yml`:
+
+```yaml
+input:
+  format: csv_posts
+  posts: my_data.csv
+
+name: my_dataset
+
+topic_model:
+  embedder: all-MiniLM-L6-v2
+  min_topic_size: 50
+
+network:
+  type: multilayer_repost
+
+output_dir: ./out/my_dataset
+```
+
+Run it: `topiclayers run my_config.yml`
+
+## Checking progress
+
+Long runs write a live status file to `<output_dir>/run_status.json`. Check the current stage, elapsed time, and ETA from another terminal without touching the running job:
+
+```bash
+topiclayers status out/my_dataset
+```
+
+Example output:
+
+```
+Stage 3/7: embed
+Status: running
+Run: my_dataset
+Progress: 412000/1200000 (34%)
+Stage elapsed: 18m 12s
+Stage ETA: ~35m 20s
+Total elapsed: 21m 05s
+```
+
+Stages are `load → data → embed → topic_model → label → network → manifest`. Stages with a per-item counter (data, embed, network) report a live ETA. Opaque stages (BERTopic's UMAP+HDBSCAN) fall back to the median duration of past runs, stored in `<output_dir>/cache/stage_timings.json`.
+
+## Topic labeling with an LLM (optional)
+
+After clustering, the pipeline can ask a local LLM to write one short, readable
+label per topic (instead of raw keyword lists like `-1_proclamation_plante_trending`).
+Default is **Ollama** — free, local, nothing leaves your machine:
+
+```bash
+# one-time setup
+pip install 'topiclayers[labeling]'
+ollama pull qwen2.5:7b
+
+# start the server in another terminal
+ollama serve
+```
+
+Then just run the pipeline as usual (`label_model` is on by default). Any
+[LiteLLM](https://docs.litellm.ai/docs/providers) model string works:
+
+```yaml
+topic_model:
+  label_model: ollama/qwen2.5:7b      # default
+  # label_model: gpt-4o-mini          # OpenAI (needs OPENAI_API_KEY)
+  # label_model: anthropic/claude-3-haiku-20240307
+  # label_model: ""                   # disable labeling
+```
+
+### Custom / self-hosted OpenAI-compatible endpoints
+
+Any server speaking the OpenAI protocol (Unsloth, llama.cpp, vLLM, LM Studio...)
+works via `label_api_base`:
+
+```yaml
+topic_model:
+  label_model: openai/unsloth/Qwen3.8-27B-GGUF   # note the openai/ prefix
+  label_api_base: http://localhost:8888/v1
+```
+
+with the token in `.env` (key resolution order: `LABEL_API_KEY` →
+`OPENAI_LIKE_API_KEY` → `OPENAI_API_KEY`). You can also set `LABEL_API_BASE`
+in `.env` instead of the YAML. Find the exact model name your server exposes
+with `curl http://localhost:8888/v1/models`.
+
+Labeling is non-fatal: if the model server is unreachable, topics keep their
+keyword labels and everything else proceeds normally.
+
+## Input formats
+
+| Format | Extension | Description |
+|--------|-----------|-------------|
+| `twitter_jsonl` | `.json`, `.jsonl` | Twitter/X API v2 JSONL |
+| `csv_posts` | `.csv` | Generic CSV with `post_id`, `user_id`, `text` columns |
+| `parquet_posts` | `.parquet` | Same schema as CSV, Parquet format |
+
+CSV optional columns: `created_at`, `lang`, `interaction_type` (`original`/`repost`/`quote`/`reply`), `target_post_id`, `mentions` (semicolon-separated), `extra_*` passthrough columns.
+
+## What if something fails?
+
+| Symptom | Likely cause | Fix |
+|---------|-------------|-----|
+| "All topics are -1" / "no topics found" | `min_topic_size` too high or dataset too small | Halve `min_topic_size` in config, or use a larger dataset (>100 posts) |
+| "Module not found" | topiclayers not installed | `pip install -e .` |
+| "OpenAI API key not set" | Using OpenAI embedder without key | Switch `embedder` to `all-MiniLM-L6-v2` (default, works offline) |
+| "Qdrant connection refused" | Qdrant vector DB not running | Ignore — Qdrant is optional. Set `QDRANT_URL` in `.env` to enable |
+| "Cannot create multilayer network" | All posts are outliers | Reduce `min_topic_size` or provide more data |
+| "UMAP spectral layout failed" | Dataset too small (<10 posts) | Topic modeling needs more data; consider using topic labels from elsewhere |
+
+## Output files
+
+For a dataset named `<name>` (e.g. `my_dataset`), output goes to `<output_dir>/`:
+
+```
+<output_dir>/
+├── run_manifest.json              # Reproducibility metadata
+├── run_status.json                # Live stage/ETA tracking (while running)
+├── cache/
+│   └── data/
+│       ├── tweets_<name>.pkl/.csv          # Full tweet table
+│       ├── retweet_labeled_<name>.pkl/.csv # Retweets with topic labels
+│       └── manifest_<name>.json            # Cache validity key
+│   └── stage_timings.json         # Per-stage durations for ETA prediction
+└── networks/
+    ├── <name>_retweet.gml                  # Single-layer retweet network
+    ├── <name>_retweet_network_ml.gml       # Multilayer (uunet format)
+    ├── <name>_ttt.gml                      # Temporal-text bipartite network
+    └── projected/
+        └── <name>__prj_<topic>.gml         # Per-topic projected networks
+```
+
+## Requirements
+
+- Python 3.12 (uunet, used for multilayer networks, does not ship wheels for 3.13+ yet)
+- Optional: Ollama + `topiclayers[labeling]` extra (LLM topic labeling), Docker (for Qdrant vector search), OpenAI API key (for OpenAI embeddings)
+
+## Planned: JOSS software paper
+
+Once the API stabilises and the PLOS ONE core paper results are regenerated with this library,
+a short JOSS (Journal of Open Source Software) paper will be submitted with a Zenodo DOI.
+

topiclayers-0.2.0.dist-info/RECORD

@@ -0,0 +1,22 @@
+topiclayers/__init__.py,sha256=4XbKMp3QGlTC1rsUqiPIyoPTfpf8bNj6ffFWUvxIx8A,88
+topiclayers/adapters/__init__.py,sha256=VxMgBam893e87VG6eiLb9TPOfk7tOnsqRvIOq8biUzQ,221
+topiclayers/adapters/csv.py,sha256=US0EDAKyI3_s4DeE0jlItMoi_UT4QaV0gjCYy2upPKM,3142
+topiclayers/adapters/registry.py,sha256=PApnvL7404j1ZZYvYSPmkvkFyzkhGCbWiv8jkCgMyZM,1361
+topiclayers/adapters/twitter.py,sha256=SD8fa0B_UaPj9MbXoHJaQMjNyPbMovrvT9e8KjWI0-k,2504
+topiclayers/cli.py,sha256=EKC7plJK9T-gOzonhILh3AsqaiQViIQL9ta5e7ODWA8,7053
+topiclayers/config.py,sha256=LvbIslvYxKfaCiE__nR7fmN9m7LBtRVdVn86cEpr7AI,2964
+topiclayers/core/__init__.py,sha256=f4h5d3Gdj8tp0wDQYHXqZd8OMaE-NECYryFq5RAQH7A,781
+topiclayers/core/data.py,sha256=fgwk9leMZa7dHkvDP6URWgPwTW2rrdBSnudFPbLRx_c,8563
+topiclayers/core/network.py,sha256=kd65b5gROJQ6nxN_C63DgR-poiM5crJZtW3Io7eASvs,10130
+topiclayers/core/topic.py,sha256=bCRruIWU89xh06FM_zkNK2lG8lH-N5bacqvduzvq78s,28360
+topiclayers/manifest.py,sha256=rBsPgU3IPvCz5O57NDCwUWn_HYb0a9iNWAqq4dbCw8Q,2485
+topiclayers/schema.py,sha256=Mu2qIq8BkHGmgVsqgnoyD_3v8cuhTwOoFRo3yPlbR14,697
+topiclayers/status.py,sha256=onv7Fm1-aqUk10v8pycSKbV01wOk1WCqbj4-RZAL1TI,8336
+topiclayers/support/__init__.py,sha256=GCJXFQQljeyHJSTt1u6mY7qSsQzPBgBx4mNY5DEY-O8,66
+topiclayers/support/cache.py,sha256=zaup-4QmZElh-twARyPKo-uS0almLu0jJUf6Q7fjfqM,232
+topiclayers/support/repro.py,sha256=Cp_IIGl92IsATJTHSetInbRMx3MAVlyQL8iaq4sN42k,267
+topiclayers-0.2.0.dist-info/METADATA,sha256=Ku9Oj5NbC6U_BHkuBuNrg2_2GUVxJjGO8FTv4JxjaEM,7602
+topiclayers-0.2.0.dist-info/WHEEL,sha256=EGEvSphFYqXKs23-kQBeyNoJP1nrT8ZJKQoi5p5DYL8,88
+topiclayers-0.2.0.dist-info/entry_points.txt,sha256=d2gMl2jDXQpI9Rm_DFRBwpq0GvcYzXODV6YDsq3D55w,52
+topiclayers-0.2.0.dist-info/licenses/LICENSE,sha256=jcGcNA49w2iZWy8w_zBayHfzn4HjDXXf8XxLIDRJt2I,1073
+topiclayers-0.2.0.dist-info/RECORD,,

topiclayers-0.2.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: poetry-core 2.4.0
+Root-Is-Purelib: true
+Tag: py3-none-any

topiclayers-0.2.0.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+topiclayers=topiclayers.cli:main
+

topiclayers-0.2.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 Alessio Gandelli
+
+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.