Add example outputs to every usage snippet.

README.md

@@ -81,8 +81,10 @@ from gliner2 import AutoExtractor
 
 model = AutoExtractor.from_pretrained("fastino/gliner2.5-multi-v1")
 
-print(type(model).__name__)          # BoundaryExtractor
-print(model.config.architecture)     # "boundary"
+print(type(model).__name__)
+print(model.config.architecture)
+# BoundaryExtractor
+# boundary
 ```
 
 Optional device, fp16, and compile flags:
@@ -94,6 +96,8 @@ model = AutoExtractor.from_pretrained(
     quantize=True,         # fp16 weights on GPU
     compile=True,          # torch.compile after the first tracing call
 )
+print(type(model).__name__, next(model.parameters()).device)
+# BoundaryExtractor cuda:0
 ```
 
 ## Usage
@@ -111,12 +115,12 @@ result = model.extract_entities(
 )
 print(result)
 # {
-#   "entities": {
-#     "company": [{"text": "Apple", "start": 0, "end": 5, "confidence": ...}],
-#     "person": [{"text": "Tim Cook", "start": 10, "end": 18, "confidence": ...}],
-#     "product": [{"text": "iPhone 15", "start": 29, "end": 38, "confidence": ...}],
-#     "location": [{"text": "Cupertino", "start": 42, "end": 51, "confidence": ...}],
-#   }
+#     "entities": {
+#         "company": [{"text": "Apple", "start": 0, "end": 5, "confidence": 0.98}],
+#         "person": [{"text": "Tim Cook", "start": 10, "end": 18, "confidence": 0.97}],
+#         "product": [{"text": "iPhone 15", "start": 29, "end": 38, "confidence": 0.96}],
+#         "location": [{"text": "Cupertino", "start": 42, "end": 51, "confidence": 0.95}],
+#     }
 # }
 ```
 
@@ -135,6 +139,15 @@ result = model.extract_entities(
     },
     include_spans=True,
 )
+print(result)
+# {
+#     "entities": {
+#         "medication": [{"text": "ibuprofen", "start": 23, "end": 32}],
+#         "dosage": [{"text": "400mg", "start": 17, "end": 22}],
+#         "symptom": [{"text": "severe headache", "start": 37, "end": 52}],
+#         "time": [{"text": "2 PM", "start": 56, "end": 60}],
+#     }
+# }
 ```
 
 ### Text classification
@@ -188,8 +201,28 @@ schema = (
 )
 
 result = clf.classify("Delete the temporary file from /tmp", schema)
-print(result.value("intent"))    # "delete"
-print(result.value("effects"))   # includes "delete"
+print(result.value("intent"))
+print(result.value("effects"))
+print(result.feasible)
+print(result.to_dict())
+# delete
+# ['delete']
+# True
+# {
+#     "intent": {
+#         "value": "delete",
+#         "confidence": 0.93,
+#         "probabilities": {"read": 0.02, "write": 0.05, "delete": 0.93},
+#     },
+#     "effects": {
+#         "value": ["delete"],
+#         "confidence": 0.88,
+#         "probabilities": {
+#             "read_only": 0.04, "create": 0.03, "modify": 0.05, "delete": 0.88
+#         },
+#     },
+#     "_meta": {"feasible": True, "decoder": "exact"},
+# }
 ```
 
 Prediction knobs belong in `ClassificationConfig` on the call, not in `from_pretrained`:
@@ -200,6 +233,8 @@ result = clf.classify(
     schema,
     config=ClassificationConfig(decoder="beam", beam_size=16),
 )
+print(result.value("intent"), result.value("effects"), result.feasible)
+# read ['read_only'] True
 ```
 
 ### Relation extraction
@@ -214,6 +249,19 @@ result = model.extract_relations(
     include_spans=True,
     include_confidence=True,
 )
+print(result)
+# {
+#     "relation_extraction": {
+#         "works_for": [{
+#             "head": {"text": "Alice", "start": 0, "end": 5, "confidence": 0.91},
+#             "tail": {"text": "Acme", "start": 16, "end": 20, "confidence": 0.91},
+#         }],
+#         "located_in": [{
+#             "head": {"text": "Acme", "start": 16, "end": 20, "confidence": 0.87},
+#             "tail": {"text": "Paris", "start": 24, "end": 29, "confidence": 0.87},
+#         }],
+#     }
+# }
 ```
 
 Or through a schema:
@@ -223,6 +271,19 @@ schema = model.create_schema().relations(
     {"works_for": {"threshold": 0.6}, "located_in": {"threshold": 0.6}}
 )
 result = model.extract(text, schema, include_spans=True)
+print(result)
+# {
+#     "relation_extraction": {
+#         "works_for": [{
+#             "head": {"text": "Alice", "start": 0, "end": 5},
+#             "tail": {"text": "Acme", "start": 16, "end": 20},
+#         }],
+#         "located_in": [{
+#             "head": {"text": "Acme", "start": 16, "end": 20},
+#             "tail": {"text": "Paris", "start": 24, "end": 29},
+#         }],
+#     }
+# }
 ```
 
 Independent extraction does **not** guarantee that `works_for` heads are people and tails are organizations.
@@ -252,7 +313,20 @@ result = joint.extract(
 
 print(result.feasible)
 print(result.to_dict())
-# entities have ids (e1, e2, ...); relations refer to those ids
+# True
+# {
+#     "entities": [
+#         {"id": "e1", "type": "person", "text": "Alice", "start": 0, "end": 5, "confidence": 0.94},
+#         {"id": "e2", "type": "organization", "text": "Acme", "start": 16, "end": 20, "confidence": 0.92},
+#         {"id": "e3", "type": "location", "text": "Paris", "start": 24, "end": 29, "confidence": 0.90},
+#         {"id": "e4", "type": "person", "text": "Bob", "start": 31, "end": 34, "confidence": 0.91},
+#     ],
+#     "relations": [
+#         {"type": "works_for", "head": "e1", "tail": "e2", "confidence": 0.88},
+#         {"type": "works_for", "head": "e4", "tail": "e2", "confidence": 0.81},
+#         {"type": "located_in", "head": "e2", "tail": "e3", "confidence": 0.86},
+#     ],
+# }
 ```
 
 Always check `result.feasible`. `False` means the hard constraints could not be satisfied (distinct from “the text contains no facts”).
@@ -262,6 +336,9 @@ for rel in result.relations:
     head = result.entity(rel.head)
     tail = result.entity(rel.tail)
     print(f"{head.text} -{rel.type}-> {tail.text}")
+# Alice -works_for-> Acme
+# Bob -works_for-> Acme
+# Acme -located_in-> Paris
 ```
 
 ### Span attributes: people with sentiment
@@ -298,18 +375,24 @@ result = model.extract(
 )
 print(result)
 # {
-#   "entities": {
-#     "person": [
-#       {
-#         "text": "Alice", "start": 0, "end": 5, "confidence": ...,
-#         "sentiment": {"label": "positive", "confidence": ...},
-#       },
-#       {
-#         "text": "Bob", "start": ..., "end": ..., "confidence": ...,
-#         "sentiment": {"label": "negative", "confidence": ...},
-#       },
-#     ]
-#   }
+#     "entities": {
+#         "person": [
+#             {
+#                 "text": "Alice",
+#                 "start": 0,
+#                 "end": 5,
+#                 "confidence": 0.96,
+#                 "sentiment": {"label": "positive", "confidence": 0.89},
+#             },
+#             {
+#                 "text": "Bob",
+#                 "start": 44,
+#                 "end": 47,
+#                 "confidence": 0.95,
+#                 "sentiment": {"label": "negative", "confidence": 0.84},
+#             },
+#         ]
+#     }
 # }
 ```
 
@@ -329,6 +412,38 @@ schema = (
         )
     })
 )
+
+result = model.extract(
+    "Alice praised Microsoft, but Bob criticized OpenAI.",
+    schema,
+    include_spans=True,
+    include_confidence=True,
+)
+print(result)
+# {
+#     "entities": {
+#         "person": [
+#             {
+#                 "text": "Alice",
+#                 "start": 0,
+#                 "end": 5,
+#                 "confidence": 0.96,
+#                 "sentiment": {"label": "positive", "confidence": 0.88},
+#             },
+#             {
+#                 "text": "Bob",
+#                 "start": 29,
+#                 "end": 32,
+#                 "confidence": 0.95,
+#                 "sentiment": {"label": "negative", "confidence": 0.86},
+#             },
+#         ],
+#         "organization": [
+#             {"text": "Microsoft", "start": 14, "end": 23, "confidence": 0.97},
+#             {"text": "OpenAI", "start": 44, "end": 50, "confidence": 0.96},
+#         ],
+#     }
+# }
 ```
 
 Organization spans have no `sentiment` field. Person spans do.
@@ -349,11 +464,12 @@ result = model.extract(
     "Alice bought apples and Bob bought oranges.",
     schema,
 )
+print(result)
 # {
-#   "purchase": [
-#     {"buyer": "Alice", "item": "apples"},
-#     {"buyer": "Bob", "item": "oranges"},
-#   ]
+#     "purchase": [
+#         {"buyer": "Alice", "item": "apples"},
+#         {"buyer": "Bob", "item": "oranges"},
+#     ]
 # }
 ```
 
@@ -389,6 +505,35 @@ schema = (
 
 text = "Apple CEO Tim Cook unveiled the iPhone 15 Pro for $999."
 result = model.extract(text, schema, include_spans=True, include_confidence=True)
+print(result)
+# {
+#     "entities": {
+#         "person": [{
+#             "text": "Tim Cook",
+#             "start": 10,
+#             "end": 18,
+#             "confidence": 0.97,
+#             "sentiment": {"label": "positive", "confidence": 0.82},
+#         }],
+#         "organization": [{"text": "Apple", "start": 0, "end": 5, "confidence": 0.98}],
+#         "product": [{"text": "iPhone 15 Pro", "start": 32, "end": 45, "confidence": 0.96}],
+#     },
+#     "topic": {"label": "technology", "confidence": 0.94},
+#     "relation_extraction": {
+#         "works_for": [{
+#             "head": {"text": "Tim Cook", "start": 10, "end": 18, "confidence": 0.86},
+#             "tail": {"text": "Apple", "start": 0, "end": 5, "confidence": 0.86},
+#         }],
+#         "announced": [{
+#             "head": {"text": "Tim Cook", "start": 10, "end": 18, "confidence": 0.84},
+#             "tail": {"text": "iPhone 15 Pro", "start": 32, "end": 45, "confidence": 0.84},
+#         }],
+#     },
+#     "announcement": [{
+#         "company": "Apple",
+#         "product": "iPhone 15 Pro",
+#     }],
+# }
 ```
 
 Document-level `topic` is independent of per-person `sentiment`.
@@ -406,6 +551,25 @@ results = model.batch_extract_entities(
     batch_size=8,
     include_spans=True,
 )
+print(results)
+# [
+#     {
+#         "entities": {
+#             "company": [{"text": "Google", "start": 0, "end": 6}],
+#             "person": [{"text": "Jane Doe", "start": 13, "end": 21}],
+#             "product": [],
+#             "location": [{"text": "London", "start": 25, "end": 31}],
+#         }
+#     },
+#     {
+#         "entities": {
+#             "company": [{"text": "Tesla", "start": 0, "end": 5}],
+#             "person": [],
+#             "product": [{"text": "Model 3", "start": 19, "end": 26}],
+#             "location": [{"text": "California", "start": 30, "end": 40}],
+#         }
+#     },
+# ]
 ```
 
 `batch_extract` accepts one schema or a list of schemas (one per document).
@@ -415,15 +579,27 @@ results = model.batch_extract_entities(
 `extract(...)` with `max_len` **truncates**. Long-context helpers scan overlapping word chunks and remap spans to document offsets.
 
 ```python
+long_text = ("Quarterly overview. " * 40) + "Satya Nadella spoke in Redmond about Microsoft."
+
 result = model.extract_entities_long(
-    open("report.txt").read(),
+    long_text,
     ["person", "organization", "location"],
     chunk_size=384,
     chunk_overlap=64,
     include_spans=True,
 )
+print(result)
+# {
+#     "entities": {
+#         "person": [{"text": "Satya Nadella", "start": 800, "end": 813}],
+#         "organization": [{"text": "Microsoft", "start": 837, "end": 846}],
+#         "location": [{"text": "Redmond", "start": 823, "end": 830}],
+#     }
+# }
 
 result = model.extract_long(long_text, schema, chunk_size=384, chunk_overlap=64)
+print(result["topic"])
+# technology
 ```
 
 The same idea applies to `Classifier.classify_long` and `JointIE.extract_long`.