typellm 0.2.6__tar.gz → 0.3.0__tar.gz

{typellm-0.2.6 → typellm-0.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: typellm
-Version: 0.2.6
+Version: 0.3.0
 Summary: Type-Safe Decoding for Autoregressive LLMs
 License-Expression: Apache-2.0
 Project-URL: Homepage, https://typellm.ai/

{typellm-0.2.6 → typellm-0.3.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "typellm"
-version = "0.2.6"
+version = "0.3.0"
 description = "Type-Safe Decoding for Autoregressive LLMs"
 readme = "README.md"
 license = "Apache-2.0"

{typellm-0.2.6 → typellm-0.3.0}/tests/test_batching.py

@@ -94,7 +94,7 @@ class PrefixWarmupTests(unittest.TestCase):
     def test_the_context_is_warmed_before_any_batch_that_shares_it(self):
         for thinking in (False, True):
             with self.subTest(thinking=thinking):
-                client = TypeLLMClient(model="fake")
+                client = TypeLLMClient("http://127.0.0.1:30000", model="fake")
                 client.sglang = FakeServer()
                 client.generate(context="Receipt", questions=thinks(self.MIXED) if thinking else self.MIXED).result
                 warm = client.sglang.requests("count")
@@ -105,7 +105,7 @@ class PrefixWarmupTests(unittest.TestCase):
                 self.assertNotIn('{"a":', warm[0]["text"])
 
     def test_open_fields_alone_are_not_warmed(self):
-        client = TypeLLMClient(model="fake")
+        client = TypeLLMClient("http://127.0.0.1:30000", model="fake")
         client.sglang = FakeServer()
         client.generate(context="Receipt", questions={"a": {"type": "integer"}, "n": {"type": "string"}}).result
         self.assertEqual(client.sglang.requests("count"), [])
@@ -117,7 +117,7 @@ class PerFieldThinkingTests(unittest.TestCase):
                 for t in ([p["text"]] if isinstance(p["text"], str) else p["text"])]
 
     def test_only_fields_that_ask_for_it_think(self):
-        client = TypeLLMClient(model="fake")
+        client = TypeLLMClient("http://127.0.0.1:30000", model="fake")
         client.sglang = FakeServer()
         result = client.generate(context="Receipt", questions={
             "hard": {"type": "boolean", "instructions": "Hard?", "thinking": True},
@@ -133,7 +133,7 @@ class PerFieldThinkingTests(unittest.TestCase):
         self.assertTrue(any("Easy?" in t and "<think>" not in t for t in answers))
 
     def test_thinking_false_is_the_same_as_leaving_it_out(self):
-        client = TypeLLMClient(model="fake")
+        client = TypeLLMClient("http://127.0.0.1:30000", model="fake")
         client.sglang = FakeServer()
         client.generate(context="Receipt", questions={
             "a": {"type": "boolean", "instructions": "A?", "thinking": True},
@@ -146,7 +146,7 @@ class PerFieldThinkingTests(unittest.TestCase):
         self.assertFalse(any("Skip?" in t for t in prompts))
 
     def test_each_field_gets_its_own_budget(self):
-        client = TypeLLMClient(model="fake")
+        client = TypeLLMClient("http://127.0.0.1:30000", model="fake")
         client.sglang = FakeServer()
         client.sglang.thinking_budget = 500  # the client's budget, for fields without their own
         client.generate(context="Receipt", questions={
@@ -170,7 +170,7 @@ class PerFieldThinkingTests(unittest.TestCase):
                         item["meta_info"]["completion_tokens"] = 40 if thinking else 1
                 return response
 
-        client = TypeLLMClient(model="fake")
+        client = TypeLLMClient("http://127.0.0.1:30000", model="fake")
         client.sglang = Metered()
         done = client.generate(context="Receipt", questions={
             "hard": {"type": "boolean", "instructions": "Hard?", "thinking": True},
@@ -186,7 +186,8 @@ class PerFieldThinkingTests(unittest.TestCase):
         for field in ({"type": "boolean", "thinking": "yes"}, {"type": "boolean", "thinking_budget": 0},
                       {"type": "boolean", "thinking_budget": 2.5}):
             with self.subTest(field=field), self.assertRaises(SchemaError):
-                TypeLLMClient(model="fake").compile_schema({"type": "object", "properties": {"x": field}})
+                TypeLLMClient("http://127.0.0.1:30000", model="fake").compile_schema(
+                    {"type": "object", "properties": {"x": field}})
 
 
 class BatchedThinkingTests(unittest.TestCase):
@@ -198,7 +199,7 @@ class BatchedThinkingTests(unittest.TestCase):
     }
 
     def test_one_thinking_request_covers_every_prompt_in_a_layer(self):
-        client = TypeLLMClient(model="fake")
+        client = TypeLLMClient("http://127.0.0.1:30000", model="fake")
         client.sglang = FakeServer()
         result = client.generate(context="Receipt", questions=thinks(self.QUESTIONS)).result
         self.assertEqual(result, {"flag": True, "count": 7, "name": "blue", "pick": "x"})
@@ -211,7 +212,7 @@ class BatchedThinkingTests(unittest.TestCase):
             self.assertTrue(all("Reasoned." + THINK_STOP in t for t in texts))
 
     def test_dag_thinks_once_per_layer(self):
-        client = TypeLLMClient(model="fake")
+        client = TypeLLMClient("http://127.0.0.1:30000", model="fake")
         client.sglang = FakeServer()
         client.generate(context="Receipt", questions=thinks({
             "a": {"type": "boolean"}, "b": {"type": "integer"},
@@ -221,7 +222,7 @@ class BatchedThinkingTests(unittest.TestCase):
         self.assertEqual([width(p) for p in client.sglang.requests("think")], [2, 2])
 
     def test_images_count_prompt_tokens_in_one_batch(self):
-        client = TypeLLMClient(model="fake")
+        client = TypeLLMClient("http://127.0.0.1:30000", model="fake")
         client.sglang = FakeServer()
         client.generate(context="Receipt", images=[PNG],
                         questions=thinks({"a": {"type": "boolean"}, "b": {"type": "boolean"}})).result

{typellm-0.2.6 → typellm-0.3.0}/tests/test_concurrency.py

@@ -35,7 +35,7 @@ class SlowServer(FakeServer):
 
 class SharedClientTests(unittest.TestCase):
     def test_concurrent_calls_keep_their_own_prompts(self):
-        client = TypeLLMClient(model="fake")
+        client = TypeLLMClient("http://127.0.0.1:30000", model="fake")
         client.sglang = SlowServer()
         finished = threading.Barrier(8)
 
@@ -53,7 +53,7 @@ class SharedClientTests(unittest.TestCase):
                     self.assertIn(f"Receipt {n}", prompt)
 
     def test_a_seeded_call_is_reproducible_and_leaves_the_shared_stream(self):
-        client = TypeLLMClient(model="fake", seed=1)
+        client = TypeLLMClient("http://127.0.0.1:30000", model="fake", seed=1)
         client.sglang = FakeServer()
         state = client.rng.getstate()
         client.generate(context="Roll", questions=PICK, seed=5).result
@@ -65,7 +65,7 @@ class SharedClientTests(unittest.TestCase):
         self.assertNotEqual(client.rng.getstate(), state)
 
     def test_clients_pickle_after_a_call(self):
-        client = TypeLLMClient(model="fake")
+        client = TypeLLMClient("http://127.0.0.1:30000", model="fake")
         client.sglang = FakeServer()
         client.generate(context="Receipt", questions={"b": {"type": "boolean"}}).result
         copy = pickle.loads(pickle.dumps(client))
@@ -100,7 +100,7 @@ class UsageTests(unittest.TestCase):
     QUESTIONS = {"a": {"type": "integer"}, "b": {"type": "boolean"}, "c": {"type": "string"}}
 
     def test_usage_sums_every_generate_request_of_the_call(self):
-        client = TypeLLMClient(model="fake")
+        client = TypeLLMClient("http://127.0.0.1:30000", model="fake")
         client.sglang = MeteredServer()
         usage = client.generate(context="Receipt", questions=self.QUESTIONS).usage
         n = prompts_sent(client.sglang)
@@ -121,7 +121,7 @@ class UsageTests(unittest.TestCase):
                          "Usage(input_tokens=5, thinking_tokens=0, requests=2, prompt_tokens=30)")
 
     def test_concurrent_calls_count_only_their_own_requests(self):
-        client = TypeLLMClient(model="fake")
+        client = TypeLLMClient("http://127.0.0.1:30000", model="fake")
         client.sglang = MeteredServer()
         finished = threading.Barrier(4)
 
@@ -139,7 +139,7 @@ class UsageTests(unittest.TestCase):
         self.assertEqual(sum(counts), len(client.sglang.payloads))
 
     def test_a_failed_call_still_reports_the_requests_it_made(self):
-        client = TypeLLMClient(model="fake")
+        client = TypeLLMClient("http://127.0.0.1:30000", model="fake")
         client.sglang = MeteredServer(fail_after=2)
         with self.assertRaisesRegex(SGLangError, "went away") as caught:
             client.generate(context="Receipt", questions=self.QUESTIONS)
@@ -160,7 +160,7 @@ class DeadlineTests(unittest.TestCase):
                     time.sleep(0.03)
                 return super()._request(path, payload, allow_text=allow_text)
 
-        client = TypeLLMClient(model="fake")
+        client = TypeLLMClient("http://127.0.0.1:30000", model="fake")
         client.sglang = Slower()
         client.generate(context="Receipt", questions=self.QUESTIONS).result
         needed = len(client.sglang.payloads)
@@ -180,7 +180,7 @@ class DeadlineTests(unittest.TestCase):
                     cancel.set()
                 return response
 
-        client = TypeLLMClient(model="fake")
+        client = TypeLLMClient("http://127.0.0.1:30000", model="fake")
         client.sglang = Cancelling()
         with self.assertRaises(GenerationCancelled):
             client.generate(context="Receipt", questions=self.QUESTIONS, cancel=cancel).result
@@ -254,7 +254,7 @@ class DeadlineTests(unittest.TestCase):
                 self.paths.append(path)
                 return super()._request(path, payload, allow_text=allow_text)
 
-        client = TypeLLMClient(model="fake")
+        client = TypeLLMClient("http://127.0.0.1:30000", model="fake")
         client.sglang = Recording()
         client.sglang.paths = []
         for kwargs in ({"timeout": 0}, {"timeout": -1}, {"timeout": True}, {"timeout": "5"},

{typellm-0.2.6 → typellm-0.3.0}/tests/test_grammar_fields.py

@@ -61,7 +61,7 @@ class GrammarNumberTests(unittest.TestCase):
     QUESTIONS = {"a": {"type": "integer"}, "b": {"type": "number"}, "c": {"type": "integer"}}
 
     def test_every_number_of_a_layer_takes_one_request(self):
-        client = TypeLLMClient(model="fake")
+        client = TypeLLMClient("http://127.0.0.1:30000", model="fake")
         client.sglang = FakeServer()
         result = client.generate(context="Receipt", questions=self.QUESTIONS).result
         self.assertEqual(result, {"a": 7, "b": 7, "c": 7})
@@ -73,7 +73,7 @@ class GrammarNumberTests(unittest.TestCase):
         self.assertIn('{"a": 7}', client._last_prompts.get()[0])
 
     def test_numbers_and_strings_of_a_layer_share_one_request(self):
-        client = TypeLLMClient(model="fake")
+        client = TypeLLMClient("http://127.0.0.1:30000", model="fake")
         client.sglang = FakeServer()
         result = client.generate(context="Receipt", questions={
             "a": {"type": "integer"}, "n": {"type": "string"},
@@ -87,14 +87,14 @@ class GrammarNumberTests(unittest.TestCase):
         self.assertIn("null", patterns[3])
 
     def test_sampling_passes_the_temperature_and_no_truncation(self):
-        client = TypeLLMClient(model="fake", temperature=0.7, seed=1)
+        client = TypeLLMClient("http://127.0.0.1:30000", model="fake", temperature=0.7, seed=1)
         client.sglang = FakeServer()
         client.generate(context="Receipt", questions={"a": {"type": "integer"}}).result
         [params] = regex_requests(client.sglang)[0]["sampling_params"]
         self.assertEqual((params["temperature"], params["top_p"], params["top_k"]), (0.7, 1.0, -1))
 
     def test_nullable_numbers_can_be_null_in_the_same_request(self):
-        client = TypeLLMClient(model="fake")
+        client = TypeLLMClient("http://127.0.0.1:30000", model="fake")
         client.sglang = NullServer()
         result = client.generate(context="Receipt", questions={"tip": {"type": ["number", "null"]}}).result
         self.assertEqual(result, {"tip": None})
@@ -104,7 +104,7 @@ class GrammarNumberTests(unittest.TestCase):
     def test_an_incomplete_or_cut_off_number_is_an_error(self):
         for reply, finish, error in ((" 3.}", "stop", ValueError), (" 12", "length", SGLangError)):
             with self.subTest(reply=reply):
-                client = TypeLLMClient(model="fake")
+                client = TypeLLMClient("http://127.0.0.1:30000", model="fake")
                 client.sglang = ReplyServer(reply, finish)
                 with self.assertRaises(error):
                     client.generate(context="Receipt", questions={"a": {"type": "number"}}).result
@@ -112,7 +112,7 @@ class GrammarNumberTests(unittest.TestCase):
     def test_negative_and_spaceless_numbers_parse(self):
         for reply, value in ((" -3.5}", -3.5), ("42}", 42.0), (" 0", 0.0)):
             with self.subTest(reply=reply):
-                client = TypeLLMClient(model="fake")
+                client = TypeLLMClient("http://127.0.0.1:30000", model="fake")
                 client.sglang = ReplyServer(reply)
                 self.assertEqual(client.generate(context="R", questions={"a": {"type": "number"}}).result,
                                  {"a": value})

{typellm-0.2.6 → typellm-0.3.0}/tests/test_images.py

@@ -161,7 +161,7 @@ class ImageEncodingTests(unittest.TestCase):
 
 class PicklingTests(unittest.TestCase):
     def test_clients_pickle_and_copy_without_sharing_images(self):
-        client = TypeLLMClient(model="m")
+        client = TypeLLMClient("http://127.0.0.1:30000", model="m")
         for copy in (pickle.loads(pickle.dumps(client)), deepcopy(client)):
             self.assertEqual(copy.sglang.model, "m")
             token = client.sglang._active_images.set(("a",))
@@ -177,7 +177,7 @@ class PlaceholderTests(unittest.TestCase):
         self.assertEqual(FakeServerClient().image_placeholder(), VISION)
 
     def test_text_only_template_is_rejected_before_any_request(self):
-        client = TypeLLMClient(model="fake")
+        client = TypeLLMClient("http://127.0.0.1:30000", model="fake")
         client.sglang = FakeServerClient(VisionTokenizer(renders_images=False))
         with self.assertRaisesRegex(SGLangError, "does not render image content"):
             client.generate(context="Receipt", images=[PNG],
@@ -185,7 +185,7 @@ class PlaceholderTests(unittest.TestCase):
         self.assertEqual(client.sglang.generate_payloads, [])
 
     def test_context_containing_image_tokens_is_rejected(self):
-        client = TypeLLMClient(model="fake")
+        client = TypeLLMClient("http://127.0.0.1:30000", model="fake")
         client.sglang = FakeServerClient()
         with self.assertRaisesRegex(SGLangError, "2 image placeholders for 1 images"):
             client.generate(context=VISION, images=[PNG],
@@ -199,7 +199,7 @@ class ImageRequestTests(unittest.TestCase):
     }
 
     def run_generate(self, images, **kwargs):
-        client = TypeLLMClient(model="fake")
+        client = TypeLLMClient("http://127.0.0.1:30000", model="fake")
         client.sglang = FakeServerClient()
         client.generate(context="Receipt", images=images, **kwargs).result
         return client.sglang.generate_payloads
@@ -239,14 +239,14 @@ class ImageRequestTests(unittest.TestCase):
         self.assert_images_attached(self.run_generate(images, questions=dag), images)
 
     def test_numeric_decoding_carries_the_images(self):
-        client = TypeLLMClient(model="fake")
+        client = TypeLLMClient("http://127.0.0.1:30000", model="fake")
         client.sglang = FakeServerClient()
         client.generate(context="Receipt", images=[PNG],
                         questions={"n": {"type": "integer", "instructions": "Count?"}}).result
         self.assert_images_attached(client.sglang.generate_payloads, [encode_image(PNG)])
 
     def test_images_are_scoped_to_one_call(self):
-        client = TypeLLMClient(model="fake")
+        client = TypeLLMClient("http://127.0.0.1:30000", model="fake")
         client.sglang = FakeServerClient()
         client.generate(context="Receipt", images=[PNG], questions=self.QUESTIONS).result
         client.sglang.generate_payloads.clear()
@@ -273,7 +273,7 @@ class ImageRequestTests(unittest.TestCase):
 
 class ImageInputTokenTests(unittest.TestCase):
     def test_images_count_as_the_server_expands_them(self):
-        client = TypeLLMClient(model="fake-vl")
+        client = TypeLLMClient("http://127.0.0.1:30000", model="fake-vl")
         client.sglang = FakeServerClient()
         questions = {"a": {"type": "boolean"}}
         usage = client.generate(context="Receipt", images=[PNG], questions=questions).usage
@@ -302,7 +302,7 @@ class RuntimeContentTests(unittest.TestCase):
                 self.messages.append(messages)
                 return "x"
 
-        client = TypeLLMClient(model="fake")
+        client = TypeLLMClient("http://127.0.0.1:30000", model="fake")
         client.sglang = Recording()
         client.generate(context="Receipt", images=[PNG, PNG],
                         questions={"paid": {"type": "boolean", "instructions": "Paid?"}}).result

{typellm-0.2.6 → typellm-0.3.0}/tests/test_nullable.py

@@ -47,7 +47,7 @@ class CompileTests(unittest.TestCase):
 
 class RuntimeTests(unittest.TestCase):
     def test_nullable_number_can_answer_null(self):
-        client = TypeLLMClient(model="fake")
+        client = TypeLLMClient("http://127.0.0.1:30000", model="fake")
         client.sglang = NullServer()
         result = client.generate(context="Receipt", questions={
             "tip": {"type": ["number", "null"]}, "count": {"type": "integer"},
@@ -56,7 +56,7 @@ class RuntimeTests(unittest.TestCase):
         self.assertIn("Return null only if there is no value.", client._last_prompts.get()[0])
 
     def test_nullable_string_writes_null_in_its_text_request(self):
-        client = TypeLLMClient(model="fake")
+        client = TypeLLMClient("http://127.0.0.1:30000", model="fake")
         client.sglang = NullServer()
         result = client.generate(context="Receipt", questions={
             "note": {"type": ["string", "null"]}, "name": {"type": "string"},
@@ -74,7 +74,7 @@ class RuntimeTests(unittest.TestCase):
         self.assertIn('{"note": null}', client._last_prompts.get()[0])
 
     def test_nullable_boolean_scores_null_as_a_choice(self):
-        client = TypeLLMClient(model="fake")
+        client = TypeLLMClient("http://127.0.0.1:30000", model="fake")
         client.sglang = FakeSGLang(selected_ids=[ord("C")])
         result = client.generate(context="Receipt", questions={
             "paid": {"type": ["boolean", "null"], "return_probabilities": True},
@@ -83,7 +83,7 @@ class RuntimeTests(unittest.TestCase):
         self.assertEqual(set(result["paid"]["probabilities"]), {True, False, None})
 
     def test_dependents_see_null(self):
-        client = TypeLLMClient(model="fake")
+        client = TypeLLMClient("http://127.0.0.1:30000", model="fake")
         client.sglang = NullServer()
         client.generate(context="Receipt", questions={
             "tip": {"type": ["number", "null"]},

{typellm-0.2.6 → typellm-0.3.0}/tests/test_permutations.py

@@ -12,7 +12,7 @@ from tests.test_dependencies import DependencyFake
 
 class PermutationTests(unittest.TestCase):
     def run_case(self, dependent, values, **options):
-        client = TypeLLMClient(seed=42, **options)
+        client = TypeLLMClient("http://127.0.0.1:30000", seed=42, **options)
         client.sglang = DependencyFake([65] * 100)
         fields = {
             'roll': {'type': 'string' if isinstance(values[0], str) else 'integer',
@@ -61,7 +61,7 @@ class PermutationTests(unittest.TestCase):
         ] + [{'type': 'string', 'enum': ['a', 'b'], 'permutations': v}
              for v in (0, -1, True, False, 2.0, None, '8', 'AUTO', {}, [])]
         invalid.append({'type': 'integer', 'enum': list(range(7)), 'permutations': 'all'})
-        client = TypeLLMClient()
+        client = TypeLLMClient("http://127.0.0.1:30000")
         with patch.object(client.sglang, 'single_token') as tokens:
             for field in invalid:
                 with self.subTest(field=field), self.assertRaises(SchemaError):
@@ -69,7 +69,7 @@ class PermutationTests(unittest.TestCase):
             tokens.assert_not_called()
 
     def test_plain_output_boolean_enum_and_clamped_budget(self):
-        client = TypeLLMClient()
+        client = TypeLLMClient("http://127.0.0.1:30000")
         client.sglang = DependencyFake([65] * 3)
         result = client.generate(context='x', questions={
             'x': {'type': 'boolean', 'enum': [False, True], 'permutations': 100},
@@ -80,7 +80,7 @@ class PermutationTests(unittest.TestCase):
         self.assertEqual(len(client.sglang.batch_prompts[0]), 3)
 
     def test_average_probabilities_not_logits(self):
-        client = TypeLLMClient()
+        client = TypeLLMClient("http://127.0.0.1:30000")
         fake = DependencyFake()
         client.sglang = fake
         with patch.object(fake, 'score_candidates_batch', return_value=([
@@ -114,7 +114,7 @@ class PermutationTests(unittest.TestCase):
         self.assertEqual(len(value_orders(['a', 'b', 'c', 'd', 'e', 'f'])), 6)
 
     def test_auto_cancels_a_pure_position_bias(self):
-        client = TypeLLMClient()
+        client = TypeLLMClient("http://127.0.0.1:30000")
         client.sglang = DependencyFake()
         biased = {65: math.log(.5), 66: math.log(.2), 67: math.log(.15), 68: math.log(.15)}
         with patch.object(client.sglang, 'score_candidates_batch',
@@ -129,7 +129,7 @@ class PermutationTests(unittest.TestCase):
     def test_one_matches_default(self):
         outputs = []
         for setting in ({}, {'permutations': 1}):
-            client = TypeLLMClient()
+            client = TypeLLMClient("http://127.0.0.1:30000")
             client.sglang = DependencyFake([66])
             outputs.append(client.generate(context='x', questions={'x': {
                 'type': 'string', 'enum': ['a', 'b'], 'return_probabilities': True, **setting}}).result)

{typellm-0.2.6 → typellm-0.3.0}/tests/test_prefill.py

@@ -13,7 +13,7 @@ class PrefillTests(unittest.TestCase):
     }
 
     def run_generate(self, questions, **kwargs):
-        client = TypeLLMClient(model="fake")
+        client = TypeLLMClient("http://127.0.0.1:30000", model="fake")
         client.sglang = FakeServer()
         result = client.generate(context="Receipt", questions=questions, **kwargs).result
         return client, result
@@ -74,12 +74,14 @@ class StringConstraintTests(unittest.TestCase):
         client._request = text_reply(' "say \\"hi\\""}')
         self.assertEqual(client.generate_texts(['{"a":'], after_key=True), ['say "hi"'])
 
-    def test_an_unfinished_string_fails(self):
-        from typellm import SGLangError
+    def test_running_out_of_tokens_cuts_the_string_off(self):
+        # A string stops at text_max_tokens: the text written by then is its value.
         client = FakeServer()
-        client._request = text_reply("Edamame and", finish="length")
-        with self.assertRaisesRegex(SGLangError, "did not complete normally"):
-            client.generate_texts(['{"a":'], after_key=True)
+        for text, value in [(' "Edamame and', "Edamame and"),
+                            (' "tab\\', "tab"),  # cut inside an escape
+                            (' "smile \\ud83d\\ude', "smile ")]:  # cut inside a surrogate pair
+            client._request = text_reply(text, finish="length")
+            self.assertEqual(client.generate_texts(['{"a":'], after_key=True), [value])
 
 
 if __name__ == "__main__":

{typellm-0.2.6 → typellm-0.3.0}/tests/test_probabilities.py

@@ -36,7 +36,7 @@ class FieldProbabilityTests(unittest.TestCase):
             {'type': 'boolean', 'return_probabilities': value}
             for value in (None, 0, 1, 'true')
         ]
-        client = TypeLLMClient()
+        client = TypeLLMClient("http://127.0.0.1:30000")
         with patch.object(client.sglang, 'single_token') as tokens:
             for field in fields:
                 with self.subTest(field=field), self.assertRaises(SchemaError):

{typellm-0.2.6 → typellm-0.3.0}/tests/test_prompts.py

@@ -4,7 +4,7 @@ from typellm import TypeLLMClient
 
 
 def prompts(fields):
-    client = TypeLLMClient(model="fake")
+    client = TypeLLMClient("http://127.0.0.1:30000", model="fake")
     client.sglang.single_token = lambda label: (ord(label), label)
     return {c.name: c.opening_text() for c in client.compile_schema({"type": "object", "properties": fields})}
 

{typellm-0.2.6 → typellm-0.3.0}/tests/test_text.py

@@ -29,7 +29,7 @@ class TextTests(unittest.TestCase):
             self.assertEqual(client.generate_texts(['p']),[''])
 
     def test_mixed_fields_run_together(self):
-        client=TypeLLMClient()
+        client=TypeLLMClient("http://127.0.0.1:30000")
         fake=FakeSGLang([ord('7'),3,ord('A')])
         calls=[]
         def generate(prefixes, **kwargs):
@@ -57,10 +57,10 @@ class TextTests(unittest.TestCase):
             self.assertEqual(constructor.call_args.kwargs['text_max_tokens'],24)
         for budget in (0,-1,True):
             with self.assertRaises(ValueError):
-                TypeLLMClient(text_max_tokens=budget)
+                TypeLLMClient("http://127.0.0.1:30000", text_max_tokens=budget)
 
     def test_thinking_then_constrained_text(self):
-        client=TypeLLMClient()
+        client=TypeLLMClient("http://127.0.0.1:30000")
         client.sglang._context_length_cache=8192
         client.sglang._chat_tokenizer=FakeChatTokenizer()
         client.sglang._chat_tokenizer.apply_chat_template=lambda *args,**kw: "assistant\n<think>\n" if kw["enable_thinking"] else "completed"