UncountablePythonSDK 0.0.24__py3-none-any.whl → 0.0.131__py3-none-any.whl

pkgs/type_spec/value_spec/__main__.py

@@ -13,16 +13,19 @@ One of the following can be specified on the name of a argument:
 After that you can also specify a `!` indicating the argument may not be null.
 If this is not specified, then a null input on this argument should produce a null output.
 We prefer not to use `!` as we want to encourage null pass-through where possible.
-If null is allowed as a legitimate value, such as in conditionals like `if`, then `!` must be specified.
+
+If null is allowed as a legitimate value, such as in conditionals like `is_null`,
+then `!usenull` must be specified, this distinguishes it from the pass-through case.
+The accepted argument type must accept "None", it is not implied.
 """
 
 import sys
-from typing import TypeVar, cast
+from typing import Match, Pattern, TypeVar, cast
 
 import regex as re
-import yaml
 
 from main.base.types import base_t, value_spec_t
+from pkgs.serialization import yaml
 
 from ..util import parse_type_str, rewrite_file
 from .convert_type import convert_to_value_spec_type
@@ -53,7 +56,7 @@ class Source:
     def has_more(self) -> bool:
         return self._at < len(self._text)
 
-    def match(self, expression: re.Pattern) -> re.Match | None:
+    def match(self, expression: Pattern[str]) -> Match[str] | None:
         self.skip_space()
         m = expression.match(self._text, self._at)
         if m is not None:
@@ -84,7 +87,7 @@ class Source:
         return self._text[start : self._at]
 
 
-_re_argument_name = re.compile(r"([a-z_]+)(\?|\+)?(!)?:")
+_re_argument_name = re.compile(r"([a-z_]+)(\?|\+)?(!|!usenull)?:")
 
 
 def parse_function_signature(text: str) -> ParsedFunctionSignature:
@@ -101,11 +104,18 @@ def parse_function_signature(text: str) -> ParsedFunctionSignature:
 
         type_str = source.extract_type()
         ref_name = arg_group.group(1)
-        is_missing = arg_group.group(2) == "?"
-        is_repeating = arg_group.group(2) == "+"
-        pass_null = arg_group.group(3) is None
+        # is_missing = arg_group.group(2) == "?"
+        # is_repeating = arg_group.group(2) == "+"
         type_path = parse_type_str(type_str)
 
+        match arg_group.group(3):
+            case "!":
+                on_null = value_spec_t.OnNull.DISALLOW
+            case "!usenull":
+                on_null = value_spec_t.OnNull.USE
+            case _:
+                on_null = value_spec_t.OnNull.PASS
+
         extant = value_spec_t.ArgumentExtant.REQUIRED
         extant_marker = arg_group.group(2)
         if extant_marker == "?":
@@ -116,7 +126,7 @@ def parse_function_signature(text: str) -> ParsedFunctionSignature:
         arguments.append(
             ParsedFunctionArgument(
                 ref_name=ref_name,
-                pass_null=pass_null,
+                on_null=on_null,
                 extant=extant,
                 type_path=type_path,
             )
@@ -145,6 +155,7 @@ key_return = "return"
 key_description = "description"
 key_brief = "brief"
 key_name = "name"
+key_draft = "draft"
 
 
 TypeT = TypeVar("TypeT")
@@ -208,7 +219,7 @@ def main() -> None:
                         name=arg_name,
                         description=arg_description,
                         type=convert_to_value_spec_type(in_argument.type_path),
-                        pass_null=in_argument.pass_null,
+                        on_null=in_argument.on_null,
                         extant=in_argument.extant,
                     )
                 )
@@ -219,6 +230,11 @@ def main() -> None:
 
             brief = get_as(spec, key_brief, str)
             description = get_as(spec, key_description, str)
+            draft = (
+                get_as(spec, key_draft, bool)
+                if spec.get(key_draft) is not None
+                else None
+            )
 
             return_value = get(spec, key_return)
             where.append("return")
@@ -235,6 +251,7 @@ def main() -> None:
                         type=convert_to_value_spec_type(parsed.return_type_path),
                         description=return_description,
                     ),
+                    draft=draft,
                 )
             )
             where.pop()

pkgs/type_spec/value_spec/convert_type.py

@@ -25,10 +25,17 @@ TYPE_MAP = {
     "List": MappedType(base_type=value_spec_t.BaseType.LIST, param_count=1),
     "Optional": MappedType(base_type=value_spec_t.BaseType.OPTIONAL, param_count=1),
     "String": MappedType(base_type=value_spec_t.BaseType.STRING),
-    "Union": MappedType(base_type=value_spec_t.BaseType.UNION, variable_param_count=True),
+    "Union": MappedType(
+        base_type=value_spec_t.BaseType.UNION, variable_param_count=True
+    ),
     # not part of type_spec's types now
     "Symbol": MappedType(base_type=value_spec_t.BaseType.SYMBOL),
     "Any": MappedType(base_type=value_spec_t.BaseType.ANY),
+    "None": MappedType(base_type=value_spec_t.BaseType.NONE),
+    "Tuple": MappedType(
+        base_type=value_spec_t.BaseType.TUPLE, variable_param_count=True
+    ),
+    "Never": MappedType(base_type=value_spec_t.BaseType.NEVER),
 }
 
 
@@ -54,3 +61,16 @@ def convert_to_value_spec_type(parsed: ParsedTypePath) -> value_spec_t.ValueType
     return value_spec_t.ValueType(base_type=mapped.base_type, parameters=parameters)
 
     # Our formatter was duplicating the previous line for an unknown reason, this comment blocks that
+
+
+def convert_from_value_spec_type(
+    base_type: value_spec_t.BaseType,
+) -> str:
+    for type_spec_type, mapped_type in TYPE_MAP.items():
+        if (
+            mapped_type.base_type == base_type
+            and mapped_type.param_count == 0
+            and mapped_type.variable_param_count is False
+        ):
+            return type_spec_type
+    raise ValueError(f"invalid value spec type {base_type}")

pkgs/type_spec/value_spec/emit_python.py

@@ -70,14 +70,19 @@ def _emit_function_wrapper(function: value_spec_t.Function) -> str:
         else:
             python_type = _emit_python_type(argument.type)
             if (
-                argument.pass_null
+                argument.on_null == value_spec_t.OnNull.PASS
                 or argument.extant == value_spec_t.ArgumentExtant.MISSING
             ):
                 python_type += " | None"
                 any_pass_null = True
+
+            if python_type.startswith("base_t.ExtJsonValue"):
+                return_statement = f"self._extract({index})"
+            else:
+                return_statement = f"cast({python_type}, self._extract({index}))"
             out.write(
                 f"""{INDENT}def get_{argument.ref_name}(self) -> {python_type}:
-{INDENT}{INDENT}return cast({python_type}, self._extract({index}))
+{INDENT}{INDENT}return {return_statement}
 """
             )
         out.write("\n")
@@ -160,8 +165,12 @@ def _emit_function(function: value_spec_t.Function, indent: str) -> str:
     sub_indent = indent + INDENT
     out.write(f"{_function_symbol_name(function)} = value_spec_t.Function(\n")
     out.write(f"{sub_indent}name={encode_common_string(function.name)},\n")
-    out.write(f"{sub_indent}description={encode_common_string(function.description)},\n")
+    out.write(
+        f"{sub_indent}description={encode_common_string(function.description)},\n"
+    )
     out.write(f"{sub_indent}brief={encode_common_string(function.brief)},\n")
+    if function.draft:
+        out.write(f"{sub_indent}draft={function.draft},\n")
     out.write(
         f"{sub_indent}return_value={_emit_function_return(function.return_value, sub_indent)},\n"
     )
@@ -184,16 +193,25 @@ def _emit_argument(argument: value_spec_t.FunctionArgument, indent: str) -> str:
     out.write("value_spec_t.FunctionArgument(\n")
     out.write(f"{sub_indent}ref_name={encode_common_string(argument.ref_name)},\n")
     out.write(f"{sub_indent}name={encode_common_string(argument.name)},\n")
-    out.write(f"{sub_indent}description={encode_common_string(argument.description)},\n")
-    out.write(f"{sub_indent}pass_null={str(argument.pass_null)},\n")
-    out.write(f"{sub_indent}extant=value_spec_t.ArgumentExtant.{argument.extant.name},\n")
+    out.write(
+        f"{sub_indent}description={encode_common_string(argument.description)},\n"
+    )
+    # Quick enum emit since we have only one such type here
+    out.write(
+        f"{sub_indent}on_null=value_spec_t.OnNull.{str(argument.on_null).upper()},\n"
+    )
+    out.write(
+        f"{sub_indent}extant=value_spec_t.ArgumentExtant.{argument.extant.name},\n"
+    )
     out.write(f"{sub_indent}type={_emit_type(argument.type, sub_indent)},\n")
     out.write(f"{indent})")
 
     return out.getvalue()
 
 
-def _emit_function_return(return_value: value_spec_t.FunctionReturn, indent: str) -> str:
+def _emit_function_return(
+    return_value: value_spec_t.FunctionReturn, indent: str
+) -> str:
     out = io.StringIO()
 
     sub_indent = indent + INDENT

pkgs/type_spec/value_spec/types.py

@@ -8,7 +8,7 @@ from ..util import ParsedTypePath
 @dataclass(kw_only=True, frozen=True)
 class ParsedFunctionArgument:
     ref_name: str
-    pass_null: bool
+    on_null: value_spec_t.OnNull
     extant: value_spec_t.ArgumentExtant
     type_path: ParsedTypePath
 

uncountable/__init__.py

@@ -1,5 +1,4 @@
-from . import types
-from . import core
+from . import core, types
 
 __all__ = []
 __all__ += types.__all__

uncountable/core/__init__.py

@@ -1,5 +1,13 @@
-from .client import AuthDetailsApiKey, Client
-from .file_upload import MediaFileUpload, UploadedFile
 from .async_batch import AsyncBatchProcessor
+from .client import Client
+from .file_upload import MediaFileUpload, UploadedFile
+from .types import AuthDetailsApiKey, AuthDetailsOAuth
 
-__all__: list[str] = ["AuthDetailsApiKey", "AsyncBatchProcessor", "Client", "MediaFileUpload", "UploadedFile"]
+__all__: list[str] = [
+    "AuthDetailsApiKey",
+    "AuthDetailsOAuth",
+    "AsyncBatchProcessor",
+    "Client",
+    "MediaFileUpload",
+    "UploadedFile",
+]

uncountable/core/async_batch.py

@@ -1,22 +1,37 @@
 from uncountable.core.client import Client
+from uncountable.types import async_batch_t, base_t
 from uncountable.types.async_batch import AsyncBatchRequest
 from uncountable.types.async_batch_processor import AsyncBatchProcessorBase
-from uncountable.types import async_batch_t, base_t
+
+
+class AsyncBatchSubmissionError(Exception):
+    pass
 
 
 class AsyncBatchProcessor(AsyncBatchProcessorBase):
     _client: Client
     _queue: list[AsyncBatchRequest]
+    _submitted_job_ids: list[base_t.ObjectId]
 
     def __init__(self, *, client: Client) -> None:
         super().__init__()
         self._client = client
         self._queue = []
+        self._submitted_job_ids = []
 
     def _enqueue(self, req: async_batch_t.AsyncBatchRequest) -> None:
         self._queue.append(req)
 
+    def current_queue_size(self) -> int:
+        return len(self._queue)
+
     def send(self) -> base_t.ObjectId:
+        if len(self._queue) == 0:
+            raise AsyncBatchSubmissionError("queue is empty")
         job_id = self._client.execute_batch_load_async(requests=self._queue).job_id
+        self._submitted_job_ids.append(job_id)
         self._queue = []
         return job_id
+
+    def get_submitted_job_ids(self) -> list[base_t.ObjectId]:
+        return self._submitted_job_ids