unitycatalog-client 0.2.1__py3-none-any.whl

unitycatalog/client/models/create_function.py

@@ -0,0 +1,163 @@
+# coding: utf-8
+
+"""
+    Unity Catalog API
+
+    No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator)
+
+    The version of the OpenAPI document: 0.1
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+    Do not edit the class manually.
+"""  # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re  # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field, StrictBool, StrictStr, field_validator
+from typing import Any, ClassVar, Dict, List, Optional
+from unitycatalog.client.models.column_type_name import ColumnTypeName
+from unitycatalog.client.models.dependency_list import DependencyList
+from unitycatalog.client.models.function_parameter_infos import FunctionParameterInfos
+from typing import Optional, Set
+from typing_extensions import Self
+
+class CreateFunction(BaseModel):
+    """
+    CreateFunction
+    """ # noqa: E501
+    name: StrictStr = Field(description="Name of function, relative to parent schema.")
+    catalog_name: StrictStr = Field(description="Name of parent catalog.")
+    schema_name: StrictStr = Field(description="Name of parent schema relative to its parent catalog.")
+    input_params: FunctionParameterInfos
+    data_type: ColumnTypeName
+    full_data_type: StrictStr = Field(description="Pretty printed function data type.")
+    return_params: Optional[FunctionParameterInfos] = None
+    routine_body: StrictStr = Field(description="Function language. When **EXTERNAL** is used, the language of the routine function should be specified in the __external_language__ field,  and the __return_params__ of the function cannot be used (as **TABLE** return type is not supported), and the __sql_data_access__ field must be **NO_SQL**. ")
+    routine_definition: StrictStr = Field(description="Function body.")
+    routine_dependencies: Optional[DependencyList] = None
+    parameter_style: StrictStr = Field(description="Function parameter style. **S** is the value for SQL.")
+    is_deterministic: StrictBool = Field(description="Whether the function is deterministic.")
+    sql_data_access: StrictStr = Field(description="Function SQL data access.")
+    is_null_call: StrictBool = Field(description="Function null call.")
+    security_type: StrictStr = Field(description="Function security type.")
+    specific_name: StrictStr = Field(description="Specific name of the function; Reserved for future use.")
+    comment: Optional[StrictStr] = Field(default=None, description="User-provided free-form text description.")
+    properties: StrictStr = Field(description="JSON-serialized key-value pair map, encoded (escaped) as a string.")
+    external_language: Optional[StrictStr] = Field(default=None, description="External language of the function.")
+    __properties: ClassVar[List[str]] = ["name", "catalog_name", "schema_name", "input_params", "data_type", "full_data_type", "return_params", "routine_body", "routine_definition", "routine_dependencies", "parameter_style", "is_deterministic", "sql_data_access", "is_null_call", "security_type", "specific_name", "comment", "properties", "external_language"]
+
+    @field_validator('routine_body')
+    def routine_body_validate_enum(cls, value):
+        """Validates the enum"""
+        if value not in set(['SQL', 'EXTERNAL']):
+            raise ValueError("must be one of enum values ('SQL', 'EXTERNAL')")
+        return value
+
+    @field_validator('parameter_style')
+    def parameter_style_validate_enum(cls, value):
+        """Validates the enum"""
+        if value not in set(['S']):
+            raise ValueError("must be one of enum values ('S')")
+        return value
+
+    @field_validator('sql_data_access')
+    def sql_data_access_validate_enum(cls, value):
+        """Validates the enum"""
+        if value not in set(['CONTAINS_SQL', 'READS_SQL_DATA', 'NO_SQL']):
+            raise ValueError("must be one of enum values ('CONTAINS_SQL', 'READS_SQL_DATA', 'NO_SQL')")
+        return value
+
+    @field_validator('security_type')
+    def security_type_validate_enum(cls, value):
+        """Validates the enum"""
+        if value not in set(['DEFINER']):
+            raise ValueError("must be one of enum values ('DEFINER')")
+        return value
+
+    model_config = ConfigDict(
+        populate_by_name=True,
+        validate_assignment=True,
+        protected_namespaces=(),
+    )
+
+
+    def to_str(self) -> str:
+        """Returns the string representation of the model using alias"""
+        return pprint.pformat(self.model_dump(by_alias=True))
+
+    def to_json(self) -> str:
+        """Returns the JSON representation of the model using alias"""
+        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+        return json.dumps(self.to_dict())
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Optional[Self]:
+        """Create an instance of CreateFunction from a JSON string"""
+        return cls.from_dict(json.loads(json_str))
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Return the dictionary representation of the model using alias.
+
+        This has the following differences from calling pydantic's
+        `self.model_dump(by_alias=True)`:
+
+        * `None` is only added to the output dict for nullable fields that
+          were set at model initialization. Other fields with value `None`
+          are ignored.
+        """
+        excluded_fields: Set[str] = set([
+        ])
+
+        _dict = self.model_dump(
+            by_alias=True,
+            exclude=excluded_fields,
+            exclude_none=True,
+        )
+        # override the default output from pydantic by calling `to_dict()` of input_params
+        if self.input_params:
+            _dict['input_params'] = self.input_params.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of return_params
+        if self.return_params:
+            _dict['return_params'] = self.return_params.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of routine_dependencies
+        if self.routine_dependencies:
+            _dict['routine_dependencies'] = self.routine_dependencies.to_dict()
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of CreateFunction from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "name": obj.get("name"),
+            "catalog_name": obj.get("catalog_name"),
+            "schema_name": obj.get("schema_name"),
+            "input_params": FunctionParameterInfos.from_dict(obj["input_params"]) if obj.get("input_params") is not None else None,
+            "data_type": obj.get("data_type"),
+            "full_data_type": obj.get("full_data_type"),
+            "return_params": FunctionParameterInfos.from_dict(obj["return_params"]) if obj.get("return_params") is not None else None,
+            "routine_body": obj.get("routine_body"),
+            "routine_definition": obj.get("routine_definition"),
+            "routine_dependencies": DependencyList.from_dict(obj["routine_dependencies"]) if obj.get("routine_dependencies") is not None else None,
+            "parameter_style": obj.get("parameter_style"),
+            "is_deterministic": obj.get("is_deterministic"),
+            "sql_data_access": obj.get("sql_data_access"),
+            "is_null_call": obj.get("is_null_call"),
+            "security_type": obj.get("security_type"),
+            "specific_name": obj.get("specific_name"),
+            "comment": obj.get("comment"),
+            "properties": obj.get("properties"),
+            "external_language": obj.get("external_language")
+        })
+        return _obj
+
+

unitycatalog/client/models/create_function_request.py

@@ -0,0 +1,91 @@
+# coding: utf-8
+
+"""
+    Unity Catalog API
+
+    No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator)
+
+    The version of the OpenAPI document: 0.1
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+    Do not edit the class manually.
+"""  # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re  # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict
+from typing import Any, ClassVar, Dict, List
+from unitycatalog.client.models.create_function import CreateFunction
+from typing import Optional, Set
+from typing_extensions import Self
+
+class CreateFunctionRequest(BaseModel):
+    """
+    CreateFunctionRequest
+    """ # noqa: E501
+    function_info: CreateFunction
+    __properties: ClassVar[List[str]] = ["function_info"]
+
+    model_config = ConfigDict(
+        populate_by_name=True,
+        validate_assignment=True,
+        protected_namespaces=(),
+    )
+
+
+    def to_str(self) -> str:
+        """Returns the string representation of the model using alias"""
+        return pprint.pformat(self.model_dump(by_alias=True))
+
+    def to_json(self) -> str:
+        """Returns the JSON representation of the model using alias"""
+        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+        return json.dumps(self.to_dict())
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Optional[Self]:
+        """Create an instance of CreateFunctionRequest from a JSON string"""
+        return cls.from_dict(json.loads(json_str))
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Return the dictionary representation of the model using alias.
+
+        This has the following differences from calling pydantic's
+        `self.model_dump(by_alias=True)`:
+
+        * `None` is only added to the output dict for nullable fields that
+          were set at model initialization. Other fields with value `None`
+          are ignored.
+        """
+        excluded_fields: Set[str] = set([
+        ])
+
+        _dict = self.model_dump(
+            by_alias=True,
+            exclude=excluded_fields,
+            exclude_none=True,
+        )
+        # override the default output from pydantic by calling `to_dict()` of function_info
+        if self.function_info:
+            _dict['function_info'] = self.function_info.to_dict()
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of CreateFunctionRequest from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "function_info": CreateFunction.from_dict(obj["function_info"]) if obj.get("function_info") is not None else None
+        })
+        return _obj
+
+

unitycatalog/client/models/create_model_version.py

@@ -0,0 +1,97 @@
+# coding: utf-8
+
+"""
+    Unity Catalog API
+
+    No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator)
+
+    The version of the OpenAPI document: 0.1
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+    Do not edit the class manually.
+"""  # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re  # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field, StrictStr
+from typing import Any, ClassVar, Dict, List, Optional
+from typing import Optional, Set
+from typing_extensions import Self
+
+class CreateModelVersion(BaseModel):
+    """
+    CreateModelVersion
+    """ # noqa: E501
+    model_name: StrictStr = Field(description="Name of registered model, relative to parent schema.")
+    catalog_name: StrictStr = Field(description="Name of parent catalog.")
+    schema_name: StrictStr = Field(description="Name of parent schema relative to its parent catalog.")
+    source: StrictStr = Field(description="URI indicating the location of the source model artifacts.")
+    run_id: Optional[StrictStr] = Field(default=None, description="The run id used by the ML package that generated the model.")
+    comment: Optional[StrictStr] = Field(default=None, description="User-provided free-form text description.")
+    __properties: ClassVar[List[str]] = ["model_name", "catalog_name", "schema_name", "source", "run_id", "comment"]
+
+    model_config = ConfigDict(
+        populate_by_name=True,
+        validate_assignment=True,
+        protected_namespaces=(),
+    )
+
+
+    def to_str(self) -> str:
+        """Returns the string representation of the model using alias"""
+        return pprint.pformat(self.model_dump(by_alias=True))
+
+    def to_json(self) -> str:
+        """Returns the JSON representation of the model using alias"""
+        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+        return json.dumps(self.to_dict())
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Optional[Self]:
+        """Create an instance of CreateModelVersion from a JSON string"""
+        return cls.from_dict(json.loads(json_str))
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Return the dictionary representation of the model using alias.
+
+        This has the following differences from calling pydantic's
+        `self.model_dump(by_alias=True)`:
+
+        * `None` is only added to the output dict for nullable fields that
+          were set at model initialization. Other fields with value `None`
+          are ignored.
+        """
+        excluded_fields: Set[str] = set([
+        ])
+
+        _dict = self.model_dump(
+            by_alias=True,
+            exclude=excluded_fields,
+            exclude_none=True,
+        )
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of CreateModelVersion from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "model_name": obj.get("model_name"),
+            "catalog_name": obj.get("catalog_name"),
+            "schema_name": obj.get("schema_name"),
+            "source": obj.get("source"),
+            "run_id": obj.get("run_id"),
+            "comment": obj.get("comment")
+        })
+        return _obj
+
+

unitycatalog/client/models/create_registered_model.py

@@ -0,0 +1,93 @@
+# coding: utf-8
+
+"""
+    Unity Catalog API
+
+    No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator)
+
+    The version of the OpenAPI document: 0.1
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+    Do not edit the class manually.
+"""  # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re  # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field, StrictStr
+from typing import Any, ClassVar, Dict, List, Optional
+from typing import Optional, Set
+from typing_extensions import Self
+
+class CreateRegisteredModel(BaseModel):
+    """
+    CreateRegisteredModel
+    """ # noqa: E501
+    name: StrictStr = Field(description="Name of model, relative to parent schema.")
+    catalog_name: StrictStr = Field(description="Name of parent catalog.")
+    schema_name: StrictStr = Field(description="Name of parent schema relative to its parent catalog.")
+    comment: Optional[StrictStr] = Field(default=None, description="User-provided free-form text description.")
+    __properties: ClassVar[List[str]] = ["name", "catalog_name", "schema_name", "comment"]
+
+    model_config = ConfigDict(
+        populate_by_name=True,
+        validate_assignment=True,
+        protected_namespaces=(),
+    )
+
+
+    def to_str(self) -> str:
+        """Returns the string representation of the model using alias"""
+        return pprint.pformat(self.model_dump(by_alias=True))
+
+    def to_json(self) -> str:
+        """Returns the JSON representation of the model using alias"""
+        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+        return json.dumps(self.to_dict())
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Optional[Self]:
+        """Create an instance of CreateRegisteredModel from a JSON string"""
+        return cls.from_dict(json.loads(json_str))
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Return the dictionary representation of the model using alias.
+
+        This has the following differences from calling pydantic's
+        `self.model_dump(by_alias=True)`:
+
+        * `None` is only added to the output dict for nullable fields that
+          were set at model initialization. Other fields with value `None`
+          are ignored.
+        """
+        excluded_fields: Set[str] = set([
+        ])
+
+        _dict = self.model_dump(
+            by_alias=True,
+            exclude=excluded_fields,
+            exclude_none=True,
+        )
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of CreateRegisteredModel from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "name": obj.get("name"),
+            "catalog_name": obj.get("catalog_name"),
+            "schema_name": obj.get("schema_name"),
+            "comment": obj.get("comment")
+        })
+        return _obj
+
+

unitycatalog/client/models/create_schema.py

@@ -0,0 +1,93 @@
+# coding: utf-8
+
+"""
+    Unity Catalog API
+
+    No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator)
+
+    The version of the OpenAPI document: 0.1
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+    Do not edit the class manually.
+"""  # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re  # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field, StrictStr
+from typing import Any, ClassVar, Dict, List, Optional
+from typing import Optional, Set
+from typing_extensions import Self
+
+class CreateSchema(BaseModel):
+    """
+    CreateSchema
+    """ # noqa: E501
+    name: StrictStr = Field(description="Name of schema, relative to parent catalog.")
+    catalog_name: StrictStr = Field(description="Name of parent catalog.")
+    comment: Optional[StrictStr] = Field(default=None, description="User-provided free-form text description.")
+    properties: Optional[Dict[str, StrictStr]] = Field(default=None, description="A map of key-value properties attached to the securable.")
+    __properties: ClassVar[List[str]] = ["name", "catalog_name", "comment", "properties"]
+
+    model_config = ConfigDict(
+        populate_by_name=True,
+        validate_assignment=True,
+        protected_namespaces=(),
+    )
+
+
+    def to_str(self) -> str:
+        """Returns the string representation of the model using alias"""
+        return pprint.pformat(self.model_dump(by_alias=True))
+
+    def to_json(self) -> str:
+        """Returns the JSON representation of the model using alias"""
+        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+        return json.dumps(self.to_dict())
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Optional[Self]:
+        """Create an instance of CreateSchema from a JSON string"""
+        return cls.from_dict(json.loads(json_str))
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Return the dictionary representation of the model using alias.
+
+        This has the following differences from calling pydantic's
+        `self.model_dump(by_alias=True)`:
+
+        * `None` is only added to the output dict for nullable fields that
+          were set at model initialization. Other fields with value `None`
+          are ignored.
+        """
+        excluded_fields: Set[str] = set([
+        ])
+
+        _dict = self.model_dump(
+            by_alias=True,
+            exclude=excluded_fields,
+            exclude_none=True,
+        )
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of CreateSchema from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "name": obj.get("name"),
+            "catalog_name": obj.get("catalog_name"),
+            "comment": obj.get("comment"),
+            "properties": obj.get("properties")
+        })
+        return _obj
+
+

unitycatalog/client/models/create_table.py

@@ -0,0 +1,113 @@
+# coding: utf-8
+
+"""
+    Unity Catalog API
+
+    No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator)
+
+    The version of the OpenAPI document: 0.1
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+    Do not edit the class manually.
+"""  # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re  # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field, StrictStr
+from typing import Any, ClassVar, Dict, List, Optional
+from unitycatalog.client.models.column_info import ColumnInfo
+from unitycatalog.client.models.data_source_format import DataSourceFormat
+from unitycatalog.client.models.table_type import TableType
+from typing import Optional, Set
+from typing_extensions import Self
+
+class CreateTable(BaseModel):
+    """
+    CreateTable
+    """ # noqa: E501
+    name: StrictStr = Field(description="Name of table, relative to parent schema.")
+    catalog_name: StrictStr = Field(description="Name of parent catalog.")
+    schema_name: StrictStr = Field(description="Name of parent schema relative to its parent catalog.")
+    table_type: TableType
+    data_source_format: DataSourceFormat
+    columns: List[ColumnInfo] = Field(description="The array of __ColumnInfo__ definitions of the table's columns.")
+    storage_location: StrictStr = Field(description="Storage root URL for external table")
+    comment: Optional[StrictStr] = Field(default=None, description="User-provided free-form text description.")
+    properties: Optional[Dict[str, StrictStr]] = Field(default=None, description="A map of key-value properties attached to the securable.")
+    __properties: ClassVar[List[str]] = ["name", "catalog_name", "schema_name", "table_type", "data_source_format", "columns", "storage_location", "comment", "properties"]
+
+    model_config = ConfigDict(
+        populate_by_name=True,
+        validate_assignment=True,
+        protected_namespaces=(),
+    )
+
+
+    def to_str(self) -> str:
+        """Returns the string representation of the model using alias"""
+        return pprint.pformat(self.model_dump(by_alias=True))
+
+    def to_json(self) -> str:
+        """Returns the JSON representation of the model using alias"""
+        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+        return json.dumps(self.to_dict())
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Optional[Self]:
+        """Create an instance of CreateTable from a JSON string"""
+        return cls.from_dict(json.loads(json_str))
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Return the dictionary representation of the model using alias.
+
+        This has the following differences from calling pydantic's
+        `self.model_dump(by_alias=True)`:
+
+        * `None` is only added to the output dict for nullable fields that
+          were set at model initialization. Other fields with value `None`
+          are ignored.
+        """
+        excluded_fields: Set[str] = set([
+        ])
+
+        _dict = self.model_dump(
+            by_alias=True,
+            exclude=excluded_fields,
+            exclude_none=True,
+        )
+        # override the default output from pydantic by calling `to_dict()` of each item in columns (list)
+        _items = []
+        if self.columns:
+            for _item in self.columns:
+                if _item:
+                    _items.append(_item.to_dict())
+            _dict['columns'] = _items
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of CreateTable from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "name": obj.get("name"),
+            "catalog_name": obj.get("catalog_name"),
+            "schema_name": obj.get("schema_name"),
+            "table_type": obj.get("table_type"),
+            "data_source_format": obj.get("data_source_format"),
+            "columns": [ColumnInfo.from_dict(_item) for _item in obj["columns"]] if obj.get("columns") is not None else None,
+            "storage_location": obj.get("storage_location"),
+            "comment": obj.get("comment"),
+            "properties": obj.get("properties")
+        })
+        return _obj
+
+