tracdap-runtime 0.7.0rc1__py3-none-any.whl → 0.8.0b2__py3-none-any.whl

tracdap/rt/_impl/validation.py

@@ -22,6 +22,7 @@ import pathlib
 
 import tracdap.rt.metadata as meta
 import tracdap.rt.exceptions as ex
+import tracdap.rt._impl.logging as log
 import tracdap.rt._impl.util as util
 
 # _Named placeholder type from API hook is needed for API type checking
@@ -74,7 +75,7 @@ class _TypeValidator:
     # Inspecting a function signature can take ~ half a second in Python 3.7
     __method_cache: tp.Dict[str, tp.Tuple[inspect.Signature, tp.Any]] = dict()
 
-    _log: logging.Logger = util.logger_for_namespace(__name__)
+    _log: logging.Logger = log.logger_for_namespace(__name__)
 
     @classmethod
     def validate_signature(cls, method: tp.Callable, *args, **kwargs):
@@ -306,6 +307,9 @@ class StaticValidator:
     __reserved_identifier_pattern = re.compile("\\A(_|trac_)", re.ASCII)
     __label_length_limit = 4096
 
+    __file_extension_pattern = re.compile('\\A[a-zA-Z0-9]+\\Z')
+    __mime_type_pattern = re.compile('\\A\\w+/[-.\\w]+(?:\\+[-.\\w]+)?\\Z')
+
     __PRIMITIVE_TYPES = [
         meta.BasicType.BOOLEAN,
         meta.BasicType.INTEGER,
@@ -321,7 +325,7 @@ class StaticValidator:
         meta.BasicType.INTEGER,
         meta.BasicType.DATE]
 
-    _log: logging.Logger = util.logger_for_namespace(__name__)
+    _log: logging.Logger = log.logger_for_namespace(__name__)
 
     @classmethod
     def is_primitive_type(cls, basic_type: meta.BasicType) -> bool:
@@ -418,49 +422,72 @@ class StaticValidator:
                 cls._valid_identifiers(param.paramProps.keys(), "entry in param props")
 
     @classmethod
-    def _check_inputs_or_outputs(cls, inputs_or_outputs):
+    def _check_inputs_or_outputs(cls, sockets):
 
-        for input_name, input_schema in inputs_or_outputs.items():
+        for socket_name, socket in sockets.items():
 
-            cls._log.info(f"Checking {input_name}")
+            if socket.objectType == meta.ObjectType.DATA:
+                cls._check_socket_schema(socket_name, socket)
+            elif socket.objectType == meta.ObjectType.FILE:
+                cls._check_socket_file_type(socket_name, socket)
+            else:
+                raise ex.EModelValidation(f"Invalid object type [{socket.objectType.name}] for [{socket_name}]")
 
-            if input_schema.dynamic:
-                if input_schema.schema and input_schema.schema.table:
-                    error = "Dynamic schemas must have schema.table = None"
-                    cls._fail(f"Invalid schema for [{input_name}]: {error}")
-                else:
-                    continue
+            label = socket.label
+            cls._check_label(label, socket_name)
+
+            if isinstance(socket, meta.ModelInputSchema):
+                if socket.inputProps is not None:
+                    cls._valid_identifiers(socket.inputProps.keys(), "entry in input props")
+            else:
+                if socket.outputProps is not None:
+                    cls._valid_identifiers(socket.outputProps.keys(), "entry in output props")
 
-            fields = input_schema.schema.table.fields
-            field_names = list(map(lambda f: f.fieldName, fields))
-            property_type = f"field in [{input_name}]"
+    @classmethod
+    def _check_socket_schema(cls, socket_name, socket):
 
-            if len(fields) == 0:
-                cls._fail(f"Invalid schema for [{input_name}]: No fields defined")
+        if socket.schema is None:
+            cls._fail(f"Missing schema requirement for [{socket_name}]")
+            return
 
-            cls._valid_identifiers(field_names, property_type)
-            cls._case_insensitive_duplicates(field_names, property_type)
+        if socket.dynamic:
+            if socket.schema and socket.schema.table:
+                error = "Dynamic schemas must have schema.table = None"
+                cls._fail(f"Invalid schema for [{socket_name}]: {error}")
+            else:
+                return
 
-            for field in fields:
-                cls._check_single_field(field, property_type)
+        fields = socket.schema.table.fields
+        field_names = list(map(lambda f: f.fieldName, fields))
+        property_type = f"field in [{socket_name}]"
 
-            label = input_schema.label
-            cls._check_label(label, input_name)
+        if len(fields) == 0:
+            cls._fail(f"Invalid schema for [{socket_name}]: No fields defined")
 
-            if isinstance(input_schema, meta.ModelInputSchema):
-                if input_schema.inputProps is not None:
-                    cls._valid_identifiers(input_schema.inputProps.keys(), "entry in input props")
-            else:
-                if input_schema.outputProps is not None:
-                    cls._valid_identifiers(input_schema.outputProps.keys(), "entry in output props")
+        cls._valid_identifiers(field_names, property_type)
+        cls._case_insensitive_duplicates(field_names, property_type)
+
+        for field in fields:
+            cls._check_single_field(field, property_type)
+
+    @classmethod
+    def _check_socket_file_type(cls, socket_name, socket):
+
+        if socket.fileType is None:
+            cls._fail(f"Missing file type requirement for [{socket_name}]")
+            return
+
+        if not cls.__file_extension_pattern.match(socket.fileType.extension):
+            cls._fail(f"Invalid extension [{socket.fileType.extension}] for [{socket_name}]")
+
+        if not cls.__mime_type_pattern.match(socket.fileType.mimeType):
+            cls._fail(f"Invalid mime type [{socket.fileType.mimeType}] for [{socket_name}]")
 
     @classmethod
     def _check_single_field(cls, field: meta.FieldSchema, property_type):
 
         # Valid identifier and not trac reserved checked separately
 
-        cls._log.info(field.fieldName)
-
         if field.fieldOrder < 0:
             cls._fail(f"Invalid {property_type}: [{field.fieldName}] fieldOrder < 0")
 

tracdap/rt/_version.py

@@ -13,4 +13,4 @@
 #  See the License for the specific language governing permissions and
 #  limitations under the License.
 
-__version__ = "0.7.0rc1"
+__version__ = "0.8.0b2"

tracdap/rt/api/__init__.py

@@ -17,13 +17,16 @@
 TRAC model API for Python
 """
 
-from .model_api import *
-from .static_api import *
-
 # Make metadata classes available to client code when importing the API package
 # Remove this import when generating docs, so metadata classes are only documented once
 from tracdap.rt.metadata import *  # noqa DOCGEN_REMOVE
 
+# static_api overrides some metadata types for backwards compatibility with pre-0.8 versions
+# Make sure it is last in the list
+from .file_types import *
+from .model_api import *
+from .static_api import *
+
 # Map basic types into the root of the API package
 
 BOOLEAN = BasicType.BOOLEAN

tracdap/rt/api/file_types.py

@@ -0,0 +1,29 @@
+#  Licensed to the Fintech Open Source Foundation (FINOS) under one or
+#  more contributor license agreements. See the NOTICE file distributed
+#  with this work for additional information regarding copyright ownership.
+#  FINOS licenses this file to you under the Apache License, Version 2.0
+#  (the "License"); you may not use this file except in compliance with the
+#  License. You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+#  limitations under the License.
+
+from tracdap.rt.metadata import *  # DOCGEN_REMOVE
+
+
+class CommonFileTypes:
+
+    TXT = FileType("txt", "text/plain")
+
+    JPG = FileType("jpg", "image/jpeg")
+    PNG = FileType("png", "image/png")
+    SVG = FileType("svg", "image/svg+xml")
+
+    WORD = FileType("docx", "application/vnd.openxmlformats-officedocument.wordprocessingml.document")
+    EXCEL = FileType("xlsx", "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet")
+    POWERPOINT = FileType("pptx", "application/vnd.openxmlformats-officedocument.presentationml.presentation")

tracdap/rt/api/hook.py

@@ -116,7 +116,7 @@ class _StaticApiHook:
     @_abc.abstractmethod
     def define_schema(
             self, *fields: _tp.Union[_meta.FieldSchema, _tp.List[_meta.FieldSchema]],
-            schema_type: _meta.SchemaType = _meta.SchemaType.TABLE) \
+            schema_type: _meta.SchemaType = _meta.SchemaType.TABLE, dynamic: bool = False) \
             -> _meta.SchemaDefinition:
 
         pass
@@ -131,21 +131,29 @@ class _StaticApiHook:
 
     @_abc.abstractmethod
     def infer_schema(self, dataset: _tp.Any) -> _meta.SchemaDefinition:
+
         pass
 
     @_abc.abstractmethod
-    def define_input_table(
-            self, *fields: _tp.Union[_meta.FieldSchema, _tp.List[_meta.FieldSchema]],
-            label: _tp.Optional[str] = None, optional: bool = False, dynamic: bool = False,
+    def define_file_type(self, extension: str, mime_type: str) -> _meta.FileType:
+
+        pass
+
+    @_abc.abstractmethod
+    def define_input(
+            self, requirement: _tp.Union[_meta.SchemaDefinition, _meta.FileType], *,
+            label: _tp.Optional[str] = None,
+            optional: bool = False, dynamic: bool = False,
             input_props: _tp.Optional[_tp.Dict[str, _tp.Any]] = None) \
             -> _meta.ModelInputSchema:
 
         pass
 
     @_abc.abstractmethod
-    def define_output_table(
-            self, *fields: _tp.Union[_meta.FieldSchema, _tp.List[_meta.FieldSchema]],
-            label: _tp.Optional[str] = None, optional: bool = False, dynamic: bool = False,
+    def define_output(
+            self, requirement: _tp.Union[_meta.SchemaDefinition, _meta.FileType], *,
+            label: _tp.Optional[str] = None,
+            optional: bool = False, dynamic: bool = False,
             output_props: _tp.Optional[_tp.Dict[str, _tp.Any]] = None) \
             -> _meta.ModelOutputSchema:
 

tracdap/rt/api/model_api.py

@@ -194,6 +194,14 @@ class TracContext(metaclass=_abc.ABCMeta):
 
         pass
 
+    def get_file(self, file_name: str) -> bytes:
+
+        pass
+
+    def get_file_stream(self, file_name: str) -> _tp.ContextManager[_tp.BinaryIO]:
+
+        pass
+
     def put_schema(self, dataset_name: str, schema: SchemaDefinition):
 
         """
@@ -283,6 +291,14 @@ class TracContext(metaclass=_abc.ABCMeta):
 
         pass
 
+    def put_file(self, file_name: str, file_content: _tp.Union[bytes, bytearray]):
+
+        pass
+
+    def put_file_stream(self, file_name: str) -> _tp.ContextManager[_tp.BinaryIO]:
+
+        pass
+
     def log(self) -> _logging.Logger:
 
         """

tracdap/rt/api/static_api.py

@@ -162,35 +162,6 @@ def define_parameter(
     return sa.define_parameter(param_name, param_type, label, default_value, param_props=param_props)
 
 
-def declare_parameter(
-        param_name: str,
-        param_type: _tp.Union[BasicType, TypeDescriptor],
-        label: str,
-        default_value: _tp.Optional[_tp.Any] = None) \
-        -> _Named[ModelParameter]:
-
-    """
-    .. deprecated:: 0.4.4
-       Use :py:func:`define_parameter` or :py:func:`P` instead.
-
-    This function is deprecated and will be removed in a future version.
-    Please use :py:func:`define_parameter() <tracdap.rt.api.define_parameter>` instead.
-
-    :type param_name: str
-    :type param_type: :py:class:`BasicType <tracdap.rt.metadata.BasicType>` |
-                      :py:class:`TypeDescriptor <tracdap.rt.metadata.TypeDescriptor>`
-
-    :type label: str
-    :type default_value: Any | None
-    :rtype: _Named[:py:class:`ModelParameter <tracdap.rt.metadata.ModelParameter>`]
-
-    :display: False
-    """
-
-    print("TRAC Warning: declare_parameter() is deprecated, please use define_parameter()", file=sys.stderr)
-
-    return define_parameter(param_name, param_type, label, default_value)
-
 
 def P(  # noqa
         param_name: str,
@@ -241,29 +212,6 @@ def define_parameters(
     return sa.define_parameters(*parameters)
 
 
-def declare_parameters(
-        *params: _tp.Union[_Named[ModelParameter], _tp.List[_Named[ModelParameter]]]) \
-        -> _tp.Dict[str, ModelParameter]:
-
-    """
-    .. deprecated:: 0.4.4
-       Use :py:func:`define_parameters` instead
-
-    This function is deprecated and will be removed in a future version.
-    Please use :py:func:`define_parameters() <tracdap.rt.api.define_parameters>` instead.
-
-    :type params: _Named[:py:class:`ModelParameter <tracdap.rt.metadata.ModelParameter>`] |
-                  List[_Named[:py:class:`ModelParameter <tracdap.rt.metadata.ModelParameter>`]]
-    :rtype: Dict[str, :py:class:`ModelParameter <tracdap.rt.metadata.ModelParameter>`]
-
-    :display: False
-    """
-
-    print("TRAC Warning: declare_parameters() is deprecated, please use define_parameters()", file=sys.stderr)
-
-    return define_parameters(*params)
-
-
 def define_field(
         field_name: str,
         field_type: BasicType,
@@ -324,45 +272,6 @@ def define_field(
         format_code, field_order)
 
 
-def declare_field(
-        field_name: str,
-        field_type: BasicType,
-        label: str,
-        business_key: bool = False,
-        categorical: bool = False,
-        not_null: _tp.Optional[bool] = None,
-        format_code: _tp.Optional[str] = None,
-        field_order: _tp.Optional[int] = None) \
-        -> FieldSchema:
-
-    """
-    .. deprecated:: 0.4.4
-       Use :py:func:`define_field` or :py:func:`F` instead.
-
-    This function is deprecated and will be removed in a future version.
-    Please use :py:func:`define_field() <tracdap.rt.api.define_field>` instead.
-
-    :type field_name: str
-    :type field_type: :py:class:`BasicType <tracdap.rt.metadata.BasicType>`
-    :type label: str
-    :type business_key: bool
-    :type categorical: bool
-    :type not_null: bool | None
-    :type format_code: str | None
-    :type field_order: int | None
-    :rtype: :py:class:`FieldSchema <tracdap.rt.metadata.FieldSchema>`
-
-    :display: False
-    """
-
-    print("TRAC Warning: declare_field() is deprecated, please use define_field()", file=sys.stderr)
-
-    return define_field(
-        field_name, field_type, label,
-        business_key, categorical, not_null,
-        format_code, field_order)
-
-
 def F(  # noqa
         field_name: str,
         field_type: BasicType,
@@ -396,7 +305,7 @@ def F(  # noqa
 
 def define_schema(
         *fields: _tp.Union[FieldSchema, _tp.List[FieldSchema]],
-        schema_type: SchemaType = SchemaType.TABLE) \
+        schema_type: SchemaType = SchemaType.TABLE, dynamic: bool = False) \
         -> SchemaDefinition:
 
     """
@@ -416,16 +325,18 @@ def define_schema(
 
     :param fields: The list of fields to include in the schema
     :param schema_type: The type of schema to create (currently only TABLE schemas are supported)
+    :param dynamic: Define a dynamic schema (fields list should be empty)
     :return: A schema definition built from the supplied fields
 
     :type fields: :py:class:`FieldSchema <tracdap.rt.metadata.FieldSchema>` |
                   List[:py:class:`FieldSchema <tracdap.rt.metadata.FieldSchema>`]
     :type schema_type: :py:class:`SchemaType <tracdap.rt.metadata.SchemaType>`
+    :type dynamic: bool
     :rtype: :py:class:`SchemaDefinition <tracdap.rt.metadata.SchemaDefinition>`
     """
 
     sa = _StaticApiHook.get_instance()
-    return sa.define_schema(*fields, schema_type=schema_type)
+    return sa.define_schema(*fields, schema_type=schema_type, dynamic=dynamic)
 
 
 def load_schema(
@@ -471,6 +382,32 @@ def load_schema(
     return sa.load_schema(package, schema_file, schema_type=schema_type)
 
 
+def define_file_type(extension: str, mime_type: str) -> FileType:
+
+    sa = _StaticApiHook.get_instance()
+    return sa.define_file_type(extension, mime_type)
+
+
+def define_input(
+        requirement: _tp.Union[SchemaDefinition, FileType], *,
+        label: _tp.Optional[str] = None,
+        optional: bool = False, dynamic: bool = False,
+        input_props: _tp.Optional[_tp.Dict[str, _tp.Any]] = None):
+
+    sa = _StaticApiHook.get_instance()
+    return sa.define_input(requirement, label=label, optional=optional, dynamic=dynamic, input_props=input_props)
+
+
+def define_output(
+        requirement: _tp.Union[SchemaDefinition, FileType], *,
+        label: _tp.Optional[str] = None,
+        optional: bool = False, dynamic: bool = False,
+        output_props: _tp.Optional[_tp.Dict[str, _tp.Any]] = None):
+
+    sa = _StaticApiHook.get_instance()
+    return sa.define_output(requirement, label=label, optional=optional, dynamic=dynamic, output_props=output_props)
+
+
 def define_input_table(
         *fields: _tp.Union[FieldSchema, _tp.List[FieldSchema]],
         label: _tp.Optional[str] = None, optional: bool = False, dynamic: bool = False,
@@ -512,34 +449,8 @@ def define_input_table(
     :rtype: :py:class:`ModelInputSchema <tracdap.rt.metadata.ModelInputSchema>`
     """
 
-    sa = _StaticApiHook.get_instance()
-
-    return sa.define_input_table(
-        *fields, label=label, optional=optional, dynamic=dynamic,
-        input_props=input_props)
-
-
-def declare_input_table(
-        *fields: _tp.Union[FieldSchema, _tp.List[FieldSchema]]) \
-        -> ModelInputSchema:
-
-    """
-    .. deprecated:: 0.4.4
-       Use :py:func:`define_input_table` instead.
-
-    This function is deprecated and will be removed in a future version.
-    Please use :py:func:`define_input_table() <tracdap.rt.api.define_input_table>` instead.
-
-    :type fields: :py:class:`FieldSchema <tracdap.rt.metadata.FieldSchema>` |
-                  List[:py:class:`FieldSchema <tracdap.rt.metadata.FieldSchema>`]
-    :rtype: :py:class:`ModelInputSchema <tracdap.rt.metadata.ModelInputSchema>`
-
-    :display: False
-    """
-
-    print("TRAC Warning: declare_input_table() is deprecated, please use define_input_table()", file=sys.stderr)
-
-    return define_input_table(*fields)
+    schema = define_schema(*fields, schema_type=SchemaType.TABLE, dynamic=dynamic)
+    return define_input(schema, label=label, optional=optional, dynamic=dynamic, input_props=input_props)
 
 
 def define_output_table(
@@ -581,11 +492,186 @@ def define_output_table(
     :rtype: :py:class:`ModelOutputSchema <tracdap.rt.metadata.ModelOutputSchema>`
     """
 
-    sa = _StaticApiHook.get_instance()
+    schema = define_schema(*fields, schema_type=SchemaType.TABLE, dynamic=dynamic)
+    return define_output(schema, label=label, optional=optional, dynamic=dynamic, output_props=output_props)
+
+
+def define_input_file(
+        extension: str, mime_type: str, *,
+        label: _tp.Optional[str] = None, optional: bool = False,
+        input_props: _tp.Optional[_tp.Dict[str, _tp.Any]] = None) \
+        -> ModelInputSchema:
+
+    file_type = define_file_type(extension, mime_type)
+    return define_input(file_type, label=label, optional=optional, input_props=input_props)
+
 
-    return sa.define_output_table(
-        *fields, label=label, optional=optional, dynamic=dynamic,
-        output_props=output_props)
+def define_output_file(
+        extension: str, mime_type: str, *,
+        label: _tp.Optional[str] = None, optional: bool = False,
+        output_props: _tp.Optional[_tp.Dict[str, _tp.Any]] = None) \
+        -> ModelOutputSchema:
+
+    file_type = define_file_type(extension, mime_type)
+    return define_output(file_type, label=label, optional=optional, output_props=output_props)
+
+
+def ModelInputSchema(  # noqa
+        schema: SchemaDefinition,
+        label: _tp.Optional[str] = None,
+        optional: bool = False,
+        dynamic: bool = False,
+        inputProps: _tp.Optional[_tp.Dict[str, Value]] = None):  # noqa
+
+    """
+    .. deprecated:: 0.8.0
+       Use :py:func:`define_input` instead.
+
+    This function is provided for compatibility with TRAC versions before 0.8.0.
+    Please use :py:func:`define_input() <tracdap.rt.api.define_input>` instead.
+
+    :display: False
+    """
+
+    input_props = inputProps or dict()
+    return define_input(schema, label=label, optional=optional, dynamic=dynamic, input_props=input_props)
+
+
+def ModelOutputSchema(  # noqa
+        schema: SchemaDefinition,
+        label: _tp.Optional[str] = None,
+        optional: bool = False,
+        dynamic: bool = False,
+        outputProps: _tp.Optional[_tp.Dict[str, Value]] = None):  # noqa
+
+    """
+    .. deprecated:: 0.8.0
+       Use :py:func:`define_output` instead.
+
+    This function is provided for compatibility with TRAC versions before 0.8.0.
+    Please use :py:func:`define_output() <tracdap.rt.api.define_output>` instead.
+
+    :display: False
+    """
+
+    output_props = outputProps or dict()
+    return define_output(schema, label=label, optional=optional, dynamic=dynamic, output_props=output_props)
+
+
+
+def declare_parameter(
+        param_name: str,
+        param_type: _tp.Union[BasicType, TypeDescriptor],
+        label: str,
+        default_value: _tp.Optional[_tp.Any] = None) \
+        -> _Named[ModelParameter]:
+
+    """
+    .. deprecated:: 0.4.4
+       Use :py:func:`define_parameter` or :py:func:`P` instead.
+
+    This function is deprecated and will be removed in a future version.
+    Please use :py:func:`define_parameter() <tracdap.rt.api.define_parameter>` instead.
+
+    :type param_name: str
+    :type param_type: :py:class:`BasicType <tracdap.rt.metadata.BasicType>` |
+                      :py:class:`TypeDescriptor <tracdap.rt.metadata.TypeDescriptor>`
+
+    :type label: str
+    :type default_value: Any | None
+    :rtype: _Named[:py:class:`ModelParameter <tracdap.rt.metadata.ModelParameter>`]
+
+    :display: False
+    """
+
+    print("TRAC Warning: declare_parameter() is deprecated, please use define_parameter()", file=sys.stderr)
+
+    return define_parameter(param_name, param_type, label, default_value)
+
+
+def declare_parameters(
+        *params: _tp.Union[_Named[ModelParameter], _tp.List[_Named[ModelParameter]]]) \
+        -> _tp.Dict[str, ModelParameter]:
+
+    """
+    .. deprecated:: 0.4.4
+       Use :py:func:`define_parameters` instead
+
+    This function is deprecated and will be removed in a future version.
+    Please use :py:func:`define_parameters() <tracdap.rt.api.define_parameters>` instead.
+
+    :type params: _Named[:py:class:`ModelParameter <tracdap.rt.metadata.ModelParameter>`] |
+                  List[_Named[:py:class:`ModelParameter <tracdap.rt.metadata.ModelParameter>`]]
+    :rtype: Dict[str, :py:class:`ModelParameter <tracdap.rt.metadata.ModelParameter>`]
+
+    :display: False
+    """
+
+    print("TRAC Warning: declare_parameters() is deprecated, please use define_parameters()", file=sys.stderr)
+
+    return define_parameters(*params)
+
+
+def declare_field(
+        field_name: str,
+        field_type: BasicType,
+        label: str,
+        business_key: bool = False,
+        categorical: bool = False,
+        not_null: _tp.Optional[bool] = None,
+        format_code: _tp.Optional[str] = None,
+        field_order: _tp.Optional[int] = None) \
+        -> FieldSchema:
+
+    """
+    .. deprecated:: 0.4.4
+       Use :py:func:`define_field` or :py:func:`F` instead.
+
+    This function is deprecated and will be removed in a future version.
+    Please use :py:func:`define_field() <tracdap.rt.api.define_field>` instead.
+
+    :type field_name: str
+    :type field_type: :py:class:`BasicType <tracdap.rt.metadata.BasicType>`
+    :type label: str
+    :type business_key: bool
+    :type categorical: bool
+    :type not_null: bool | None
+    :type format_code: str | None
+    :type field_order: int | None
+    :rtype: :py:class:`FieldSchema <tracdap.rt.metadata.FieldSchema>`
+
+    :display: False
+    """
+
+    print("TRAC Warning: declare_field() is deprecated, please use define_field()", file=sys.stderr)
+
+    return define_field(
+        field_name, field_type, label,
+        business_key, categorical, not_null,
+        format_code, field_order)
+
+
+def declare_input_table(
+        *fields: _tp.Union[FieldSchema, _tp.List[FieldSchema]]) \
+        -> ModelInputSchema:
+
+    """
+    .. deprecated:: 0.4.4
+       Use :py:func:`define_input_table` instead.
+
+    This function is deprecated and will be removed in a future version.
+    Please use :py:func:`define_input_table() <tracdap.rt.api.define_input_table>` instead.
+
+    :type fields: :py:class:`FieldSchema <tracdap.rt.metadata.FieldSchema>` |
+                  List[:py:class:`FieldSchema <tracdap.rt.metadata.FieldSchema>`]
+    :rtype: :py:class:`ModelInputSchema <tracdap.rt.metadata.ModelInputSchema>`
+
+    :display: False
+    """
+
+    print("TRAC Warning: declare_input_table() is deprecated, please use define_input_table()", file=sys.stderr)
+
+    return define_input_table(*fields)
 
 
 def declare_output_table(