Domain

CLASS	DESCRIPTION
CodedValueDomain	Domain with a CodedValue component
Domain	General Domain object
RangeDomain	Domain with a Range component

BaseDomain

BaseDomain(
    wrapped: Domain, workspace: str | Path | Dataset
)

Base class for interacting with Domains.

General setup structure is pulled from pathlib.Path since

Subclassed by:

• Modules Domain  Domain

METHOD	DESCRIPTION
sync	Sync the domain with the workspace

Source code in src/arcpie/schema/domain.py

def __init__(self, wrapped: da.Domain, workspace: str | Path | Dataset) -> None:
    from ..database import Dataset
    self._domain = wrapped
    if not isinstance(workspace, Dataset):
        self.dataset = Dataset(workspace)
        self.workspace = str(workspace)
    else:
        self.dataset = workspace
        self.workspace = str(workspace)

sync

sync() -> None

Sync the domain with the workspace

Source code in src/arcpie/schema/domain.py

def sync(self) -> None:
    """Sync the domain with the workspace"""
    matches = [d for d in da.ListDomains(self.workspace) if d.name == self.name]
    if not matches:
        raise LookupError(f'Domain {self.name} no longer exists in the parent workspace {self.workspace}')
    self._domain = matches.pop()

CodedValueDomain

CodedValueDomain(
    wrapped: Domain, workspace: str | Path | Dataset
)

Bases: Domain

Domain with a CodedValue component

Returned by:

• Modules Domain
  •  CodedValueDomain
    •  create
    •  from_table
  •  Domain
    •  create
    •  from_table
  •  RangeDomain
    •  create
    •  from_table

METHOD	DESCRIPTION
add_to	Add the domain to a root workspace/Dataset
assign_to	Assign the domain to a Field
create	Create a new domain
delete	Delete the domain
from_dict	Create a Domain object from a system domain definition
from_table	Create a CodedValue domain from a Table
sync	Sync the domain with the workspace
to_dict	Use with json.dump/dumps
to_table	Convert the domain to a Table in its workspace
used_by	Get a mapping of FeatureClass/Table -> [Field, ...] usage for the domain

Source code in src/arcpie/schema/domain.py

def __init__(self, wrapped: da.Domain, workspace: str | Path | Dataset) -> None:
    from ..database import Dataset
    self._domain = wrapped
    if not isinstance(workspace, Dataset):
        self.dataset = Dataset(workspace)
        self.workspace = str(workspace)
    else:
        self.dataset = workspace
        self.workspace = str(workspace)

add_to

add_to(workspace: Dataset) -> None

Add the domain to a root workspace/Dataset

Source code in src/arcpie/schema/domain.py

def add_to(self, workspace: Dataset) -> None:
    """Add the domain to a root workspace/Dataset"""
    if workspace.parent is not None:
        raise ValueError(f'Domains can only be added to the root Dataset!')
    CreateDomain(
        in_workspace=str(workspace.conn.resolve()), 
        domain_name=self.name, 
        domain_description=self.description,
        field_type=_DOMAIN_FIELD_TYPE_MAP[self.type],
        domain_type=_DOMAIN_TYPE_MAP[self.domainType],
        split_policy=_DOMAIN_SPLIT_POLICY_MAP[self.splitPolicy],
        merge_policy=_DOMAIN_MERGE_POLICY_MAP[self.mergePolicy],
    )
    if isinstance(self, CodedValueDomain):
        for code, value in self.codedValues.items():
            AddCodedValueToDomain(str(workspace), self.name, code, value)
    if isinstance(self, RangeDomain):
        SetValueForRangeDomain(str(workspace), self.name, *self.range)

assign_to

assign_to(
    table: Table | FeatureClass,
    field: str,
    *,
    subtype_code: int | None = None,
) -> None

Assign the domain to a Field

PARAMETER	DESCRIPTION
table	The table to apply the domain to TYPE: Table | FeatureClass
field	The field in the table to apply the domain to TYPE: str
subtype_code	An optional subtype to apply the domain to TYPE: int | None DEFAULT: None

Source code in src/arcpie/schema/domain.py

def assign_to(self, table: Table | FeatureClass, field: str,
             *,
             subtype_code: int | None = None,
             ) -> None:
    """Assign the domain to a Field

    Args:
        table: The table to apply the domain to
        field: The field in the table to apply the domain to
        subtype_code: An optional subtype to apply the domain to
    """
    field_info = table.field_defs.get(field)
    if not field_info:
        raise ValueError(f'{table.name}: {field} not found!')
    if field_info.get('field_type') not in VALID_FIELD_TYPES_FOR.get(self.type, set()):
        msg = (
            f'Domain of type {self.type} cannot be assigned to '
            f'field {field} of type {field_info.get('field_type')}'
        )
        raise ValueError(msg)

    AssignDomainToField(
        in_table=str(table),
        field_name=field,
        domain_name=self.name,
        subtype_code=subtype_code,
    )

create classmethod

create(
    workspace: str,
    name: str,
    *,
    domain_type: Literal["CodedValue"],
    field_type: DomainFieldType,
    coded_values: CodedValues,
    description: str,
    split_policy: SplitPolicy = ...,
    merge_policy: MergePolicy = ...,
) -> CodedValueDomain

create(
    workspace: str,
    name: str,
    *,
    domain_type: Literal["Range"],
    field_type: DomainFieldType,
    domain_range: RangeValue,
    description: str,
    split_policy: SplitPolicy = ...,
    merge_policy: MergePolicy = ...,
) -> RangeDomain

create(
    workspace: str,
    name: str,
    *,
    domain_type: DomainType,
    field_type: DomainFieldType,
    description: str = "",
    split_policy: SplitPolicy = "Duplicate",
    merge_policy: MergePolicy = "DefaultValue",
    domain_range: RangeValue | None = None,
    coded_values: CodedValues | None = None,
) -> CodedValueDomain | RangeDomain

Create a new domain

Source code in src/arcpie/schema/domain.py

@classmethod
def create(cls, workspace: str, name: str, 
           *,
           domain_type: DomainType,
           field_type: DomainFieldType,
           description: str = '', 
           split_policy: SplitPolicy = 'Duplicate',
           merge_policy: MergePolicy = 'DefaultValue',

           # Required by overload
           domain_range: RangeValue | None = None,
           coded_values: CodedValues | None = None) -> CodedValueDomain | RangeDomain:
    """Create a new domain"""
    assert domain_type in ['CodedValue', 'Range'], f'Invalid domain type {domain_type}'

    CreateDomain(
        in_workspace=workspace,
        domain_name=name,
        domain_description=description,
        field_type=_DOMAIN_FIELD_TYPE_MAP.get(field_type),
        domain_type=_DOMAIN_TYPE_MAP.get(domain_type),
        split_policy=_DOMAIN_SPLIT_POLICY_MAP.get(split_policy),
        merge_policy=_DOMAIN_MERGE_POLICY_MAP.get(merge_policy),
    )
    new_domain, *_ = [d for d in da.ListDomains(workspace) if d.name == name] or [None]
    if new_domain is None:
        raise ValueError(f'Something went wrong creating the Domain...')
    if domain_type == 'CodedValue':
        domain = CodedValueDomain(new_domain, workspace)
        if coded_values:
            domain.codedValues = {k: v for k, v in coded_values.items()}
        return domain
    elif domain_type == 'Range':
        domain = RangeDomain(new_domain, workspace)
        if domain_range:
            domain.range = domain_range
        return domain

delete

delete() -> None

Delete the domain

Source code in src/arcpie/schema/domain.py

def delete(self) -> None:
    """Delete the domain"""
    DeleteDomain(self.workspace, self.name)

from_dict classmethod

from_dict(
    definition: SystemDomain, workspace: str | None = None
) -> Domain

Create a Domain object from a system domain definition

Source code in src/arcpie/schema/domain.py

@classmethod
def from_dict(cls, definition: SystemDomain, workspace: str| None = None) -> Domain:
    """Create a Domain object from a system domain definition"""
    dom: da.Domain = type(f'__domain', (object,), {k: v for k,v in definition.items()})
    return cls(dom, workspace)

from_table classmethod

from_table(
    table: FeatureClass | Table,
    name: str,
    *,
    code_field: str,
    description_field: str,
    workspace: str | None = None,
    description: str | None,
    overwrite_existing: bool = False,
) -> CodedValueDomain

Create a CodedValue domain from a Table

PARAMETER	DESCRIPTION
table	The table or featureclass to create the domain from TYPE: FeatureClass | Table
name	The name of the domain TYPE: str
code_field	The field to use for codes TYPE: str
description_field	The field to use for descriptions TYPE: str
workspace	The workspace to create the domain in (default: table.workspace) TYPE: str | None DEFAULT: None
description	An optional description for the new domain TYPE: str | None
overwrite_existing	If set to True, any existing domains with the name will be replaced, otherwise new values are appended to the existing domain TYPE: bool DEFAULT: False

Source code in src/arcpie/schema/domain.py

@classmethod
def from_table(cls, table: FeatureClass | Table, name: str,
               *,
               code_field: str,
               description_field: str,
               workspace: str | None = None,
               description: str | None,
               overwrite_existing: bool = False,
               ) -> CodedValueDomain:
    """Create a CodedValue domain from a Table

    Args:
        table: The table or featureclass to create the domain from
        name: The name of the domain
        code_field: The field to use for codes
        description_field: The field to use for descriptions
        workspace: The workspace to create the domain in (default: table.workspace)
        description: An optional description for the new domain
        overwrite_existing: If set to `True`, any existing domains with the name will be replaced,<br> 
            otherwise new values are appended to the existing domain
    """
    if code_field not in table.fields or description_field not in table.fields:
        msg = (
            f'Invalid {code_field} or {description_field} not in table fields, '
            f'must be one of {table.fields}'
        )
        raise ValueError(msg)

    workspace = workspace or table.workspace
    TableToDomain(
        in_table=str(table),
        code_field=code_field,
        description_field=description_field,
        in_workspace=workspace or table.workspace,
        domain_name=name,
        domain_description=description,
        update_option='REPLACE' if overwrite_existing else 'APPEND'
    )
    return CodedValueDomain([d for d in da.ListDomains(workspace) if d.name == name].pop(), workspace)

sync

sync() -> None

Sync the domain with the workspace

Source code in src/arcpie/schema/domain.py

def sync(self) -> None:
    """Sync the domain with the workspace"""
    matches = [d for d in da.ListDomains(self.workspace) if d.name == self.name]
    if not matches:
        raise LookupError(f'Domain {self.name} no longer exists in the parent workspace {self.workspace}')
    self._domain = matches.pop()

to_dict

to_dict() -> DomainSchema

Use with json.dump/dumps

Source code in src/arcpie/schema/domain.py

def to_dict(self) -> DomainSchema:
    """Use with json.dump/dumps"""
    return {
        'name': self.name,
        'domainType': self.domainType,
        'type': self.type,
        'description': self.description,
        'codedValues': self.codedValues,
        'range': self.range,
        'mergePolicy': self.mergePolicy,
        'splitPolicy': self.splitPolicy,
        'owner': self.owner,
    }

to_table

to_table(
    table_name: str,
    *,
    code_field: str = "code",
    description_field: str = "description",
    configuration_keyword: str | None = None,
) -> Table

Convert the domain to a Table in its workspace

PARAMETER	DESCRIPTION
table_name	The name of the output table TYPE: str
code_field	The field name for the codes TYPE: str DEFAULT: 'code'
description_field	The field name for the descriptions TYPE: str DEFAULT: 'description'
configuration_keyword	An optional config keyword for the database TYPE: str | None DEFAULT: None

Source code in src/arcpie/schema/domain.py

def to_table(self, table_name: str, 
             *,
             code_field: str = 'code',
             description_field: str = 'description',
             configuration_keyword: str | None = None
             ) -> Table:
    """Convert the domain to a Table in its workspace

    Args:
        table_name: The name of the output table
        code_field: The field name for the codes
        description_field: The field name for the descriptions
        configuration_keyword: An optional config keyword for the database
    """
    if self.domainType != 'CodedValue':
        raise TypeError(f'Only `CodedValue` domains can be converted to a table')
    return Table(
        *DomainToTable(
            in_workspace=self.workspace, 
            domain_name=self.name, 
            out_table=table_name,
            code_field=code_field,
            description_field=description_field,
            configuration_keyword=configuration_keyword,
        )
    )

used_by

used_by() -> FieldUsage

Get a mapping of FeatureClass/Table -> [Field, ...] usage for the domain

Source code in src/arcpie/schema/domain.py

def used_by(self) -> FieldUsage:
    """Get a mapping of FeatureClass/Table -> [Field, ...] usage for the domain"""
    return self.dataset.domains.usage(self.name)[self.name]

Domain

Domain(wrapped: Domain, workspace: str | Path | Dataset)

Bases: BaseDomain

General Domain object

Returned by:

• Modules Domain
  •  CodedValueDomain  from_dict
  •  Domain  from_dict
  •  RangeDomain  from_dict

Subclassed by:

• Modules Domain
  •  CodedValueDomain
  •  RangeDomain

METHOD	DESCRIPTION
add_to	Add the domain to a root workspace/Dataset
assign_to	Assign the domain to a Field
create	Create a new domain
delete	Delete the domain
from_dict	Create a Domain object from a system domain definition
from_table	Create a CodedValue domain from a Table
sort	CodedValue Only
sync	Sync the domain with the workspace
to_dict	Use with json.dump/dumps
to_table	Convert the domain to a Table in its workspace
used_by	Get a mapping of FeatureClass/Table -> [Field, ...] usage for the domain

Source code in src/arcpie/schema/domain.py

def __init__(self, wrapped: da.Domain, workspace: str | Path | Dataset) -> None:
    from ..database import Dataset
    self._domain = wrapped
    if not isinstance(workspace, Dataset):
        self.dataset = Dataset(workspace)
        self.workspace = str(workspace)
    else:
        self.dataset = workspace
        self.workspace = str(workspace)

add_to

add_to(workspace: Dataset) -> None

Add the domain to a root workspace/Dataset

Source code in src/arcpie/schema/domain.py

def add_to(self, workspace: Dataset) -> None:
    """Add the domain to a root workspace/Dataset"""
    if workspace.parent is not None:
        raise ValueError(f'Domains can only be added to the root Dataset!')
    CreateDomain(
        in_workspace=str(workspace.conn.resolve()), 
        domain_name=self.name, 
        domain_description=self.description,
        field_type=_DOMAIN_FIELD_TYPE_MAP[self.type],
        domain_type=_DOMAIN_TYPE_MAP[self.domainType],
        split_policy=_DOMAIN_SPLIT_POLICY_MAP[self.splitPolicy],
        merge_policy=_DOMAIN_MERGE_POLICY_MAP[self.mergePolicy],
    )
    if isinstance(self, CodedValueDomain):
        for code, value in self.codedValues.items():
            AddCodedValueToDomain(str(workspace), self.name, code, value)
    if isinstance(self, RangeDomain):
        SetValueForRangeDomain(str(workspace), self.name, *self.range)

assign_to

assign_to(
    table: Table | FeatureClass,
    field: str,
    *,
    subtype_code: int | None = None,
) -> None

Assign the domain to a Field

PARAMETER	DESCRIPTION
table	The table to apply the domain to TYPE: Table | FeatureClass
field	The field in the table to apply the domain to TYPE: str
subtype_code	An optional subtype to apply the domain to TYPE: int | None DEFAULT: None

Source code in src/arcpie/schema/domain.py

def assign_to(self, table: Table | FeatureClass, field: str,
             *,
             subtype_code: int | None = None,
             ) -> None:
    """Assign the domain to a Field

    Args:
        table: The table to apply the domain to
        field: The field in the table to apply the domain to
        subtype_code: An optional subtype to apply the domain to
    """
    field_info = table.field_defs.get(field)
    if not field_info:
        raise ValueError(f'{table.name}: {field} not found!')
    if field_info.get('field_type') not in VALID_FIELD_TYPES_FOR.get(self.type, set()):
        msg = (
            f'Domain of type {self.type} cannot be assigned to '
            f'field {field} of type {field_info.get('field_type')}'
        )
        raise ValueError(msg)

    AssignDomainToField(
        in_table=str(table),
        field_name=field,
        domain_name=self.name,
        subtype_code=subtype_code,
    )

create classmethod

create(
    workspace: str,
    name: str,
    *,
    domain_type: Literal["CodedValue"],
    field_type: DomainFieldType,
    coded_values: CodedValues,
    description: str,
    split_policy: SplitPolicy = ...,
    merge_policy: MergePolicy = ...,
) -> CodedValueDomain

create(
    workspace: str,
    name: str,
    *,
    domain_type: Literal["Range"],
    field_type: DomainFieldType,
    domain_range: RangeValue,
    description: str,
    split_policy: SplitPolicy = ...,
    merge_policy: MergePolicy = ...,
) -> RangeDomain

create(
    workspace: str,
    name: str,
    *,
    domain_type: DomainType,
    field_type: DomainFieldType,
    description: str = "",
    split_policy: SplitPolicy = "Duplicate",
    merge_policy: MergePolicy = "DefaultValue",
    domain_range: RangeValue | None = None,
    coded_values: CodedValues | None = None,
) -> CodedValueDomain | RangeDomain

Create a new domain

Source code in src/arcpie/schema/domain.py

@classmethod
def create(cls, workspace: str, name: str, 
           *,
           domain_type: DomainType,
           field_type: DomainFieldType,
           description: str = '', 
           split_policy: SplitPolicy = 'Duplicate',
           merge_policy: MergePolicy = 'DefaultValue',

           # Required by overload
           domain_range: RangeValue | None = None,
           coded_values: CodedValues | None = None) -> CodedValueDomain | RangeDomain:
    """Create a new domain"""
    assert domain_type in ['CodedValue', 'Range'], f'Invalid domain type {domain_type}'

    CreateDomain(
        in_workspace=workspace,
        domain_name=name,
        domain_description=description,
        field_type=_DOMAIN_FIELD_TYPE_MAP.get(field_type),
        domain_type=_DOMAIN_TYPE_MAP.get(domain_type),
        split_policy=_DOMAIN_SPLIT_POLICY_MAP.get(split_policy),
        merge_policy=_DOMAIN_MERGE_POLICY_MAP.get(merge_policy),
    )
    new_domain, *_ = [d for d in da.ListDomains(workspace) if d.name == name] or [None]
    if new_domain is None:
        raise ValueError(f'Something went wrong creating the Domain...')
    if domain_type == 'CodedValue':
        domain = CodedValueDomain(new_domain, workspace)
        if coded_values:
            domain.codedValues = {k: v for k, v in coded_values.items()}
        return domain
    elif domain_type == 'Range':
        domain = RangeDomain(new_domain, workspace)
        if domain_range:
            domain.range = domain_range
        return domain

delete

delete() -> None

Delete the domain

Source code in src/arcpie/schema/domain.py

def delete(self) -> None:
    """Delete the domain"""
    DeleteDomain(self.workspace, self.name)

from_dict classmethod

from_dict(
    definition: SystemDomain, workspace: str | None = None
) -> Domain

Create a Domain object from a system domain definition

Source code in src/arcpie/schema/domain.py

@classmethod
def from_dict(cls, definition: SystemDomain, workspace: str| None = None) -> Domain:
    """Create a Domain object from a system domain definition"""
    dom: da.Domain = type(f'__domain', (object,), {k: v for k,v in definition.items()})
    return cls(dom, workspace)

from_table classmethod

from_table(
    table: FeatureClass | Table,
    name: str,
    *,
    code_field: str,
    description_field: str,
    workspace: str | None = None,
    description: str | None,
    overwrite_existing: bool = False,
) -> CodedValueDomain

Create a CodedValue domain from a Table

PARAMETER	DESCRIPTION
table	The table or featureclass to create the domain from TYPE: FeatureClass | Table
name	The name of the domain TYPE: str
code_field	The field to use for codes TYPE: str
description_field	The field to use for descriptions TYPE: str
workspace	The workspace to create the domain in (default: table.workspace) TYPE: str | None DEFAULT: None
description	An optional description for the new domain TYPE: str | None
overwrite_existing	If set to True, any existing domains with the name will be replaced, otherwise new values are appended to the existing domain TYPE: bool DEFAULT: False

Source code in src/arcpie/schema/domain.py

@classmethod
def from_table(cls, table: FeatureClass | Table, name: str,
               *,
               code_field: str,
               description_field: str,
               workspace: str | None = None,
               description: str | None,
               overwrite_existing: bool = False,
               ) -> CodedValueDomain:
    """Create a CodedValue domain from a Table

    Args:
        table: The table or featureclass to create the domain from
        name: The name of the domain
        code_field: The field to use for codes
        description_field: The field to use for descriptions
        workspace: The workspace to create the domain in (default: table.workspace)
        description: An optional description for the new domain
        overwrite_existing: If set to `True`, any existing domains with the name will be replaced,<br> 
            otherwise new values are appended to the existing domain
    """
    if code_field not in table.fields or description_field not in table.fields:
        msg = (
            f'Invalid {code_field} or {description_field} not in table fields, '
            f'must be one of {table.fields}'
        )
        raise ValueError(msg)

    workspace = workspace or table.workspace
    TableToDomain(
        in_table=str(table),
        code_field=code_field,
        description_field=description_field,
        in_workspace=workspace or table.workspace,
        domain_name=name,
        domain_description=description,
        update_option='REPLACE' if overwrite_existing else 'APPEND'
    )
    return CodedValueDomain([d for d in da.ListDomains(workspace) if d.name == name].pop(), workspace)

sort

sort(
    by: Literal["code", "value"],
    order: Literal["asc", "desc"],
) -> None

CodedValue Only

Source code in src/arcpie/schema/domain.py

def sort(self, by: Literal['code', 'value'], order: Literal['asc', 'desc']) -> None:
    """CodedValue Only"""

sync

sync() -> None

Sync the domain with the workspace

Source code in src/arcpie/schema/domain.py

def sync(self) -> None:
    """Sync the domain with the workspace"""
    matches = [d for d in da.ListDomains(self.workspace) if d.name == self.name]
    if not matches:
        raise LookupError(f'Domain {self.name} no longer exists in the parent workspace {self.workspace}')
    self._domain = matches.pop()

to_dict

to_dict() -> DomainSchema

Use with json.dump/dumps

Source code in src/arcpie/schema/domain.py

def to_dict(self) -> DomainSchema:
    """Use with json.dump/dumps"""
    return {
        'name': self.name,
        'domainType': self.domainType,
        'type': self.type,
        'description': self.description,
        'codedValues': self.codedValues,
        'range': self.range,
        'mergePolicy': self.mergePolicy,
        'splitPolicy': self.splitPolicy,
        'owner': self.owner,
    }

to_table

to_table(
    table_name: str,
    *,
    code_field: str = "code",
    description_field: str = "description",
    configuration_keyword: str | None = None,
) -> Table

Convert the domain to a Table in its workspace

PARAMETER	DESCRIPTION
table_name	The name of the output table TYPE: str
code_field	The field name for the codes TYPE: str DEFAULT: 'code'
description_field	The field name for the descriptions TYPE: str DEFAULT: 'description'
configuration_keyword	An optional config keyword for the database TYPE: str | None DEFAULT: None

Source code in src/arcpie/schema/domain.py

def to_table(self, table_name: str, 
             *,
             code_field: str = 'code',
             description_field: str = 'description',
             configuration_keyword: str | None = None
             ) -> Table:
    """Convert the domain to a Table in its workspace

    Args:
        table_name: The name of the output table
        code_field: The field name for the codes
        description_field: The field name for the descriptions
        configuration_keyword: An optional config keyword for the database
    """
    if self.domainType != 'CodedValue':
        raise TypeError(f'Only `CodedValue` domains can be converted to a table')
    return Table(
        *DomainToTable(
            in_workspace=self.workspace, 
            domain_name=self.name, 
            out_table=table_name,
            code_field=code_field,
            description_field=description_field,
            configuration_keyword=configuration_keyword,
        )
    )

used_by

used_by() -> FieldUsage

Get a mapping of FeatureClass/Table -> [Field, ...] usage for the domain

Source code in src/arcpie/schema/domain.py

def used_by(self) -> FieldUsage:
    """Get a mapping of FeatureClass/Table -> [Field, ...] usage for the domain"""
    return self.dataset.domains.usage(self.name)[self.name]

DomainManager

DomainManager(dataset: Dataset[Any])

Container for managing dataset domains

METHOD	DESCRIPTION
export_module	Export the workspace domain to a Python module that contains literals and dictionary mappings.
import_domains	Import domains from a domain mapping (DOMAINS global in exported module)
to_dict	Use with json.dump/dumps
usage	A mapping of domains to features to fields that shows usage of a domain in a dataset

Source code in src/arcpie/schema/domain.py

def __init__(self, dataset: Dataset[Any]) -> None:
    if dataset.parent is not None:
        dataset = dataset.parent
    self.dataset = dataset
    self.workspace = str(dataset)

export_module

export_module(path: str | Path) -> None

Export the workspace domain to a Python module that contains literals and dictionary mappings.

PARAMETER	DESCRIPTION
path	The export path to the module file TYPE: str | Path

Source code in src/arcpie/schema/domain.py

def export_module(self, path: str | Path) -> None:
    """Export the workspace domain to a Python module that contains literals and dictionary mappings.

    Args:
        path: The export path to the module file
    """

    path = Path(path)
    _domains = self.to_dict()

    if not path.suffix.endswith('.py'):
        path = (path / 'domains.py')

    path.parent.mkdir(exist_ok=True, parents=True)

    def _(val: Any) -> str:
        if val is None:
            return 'None'
        return repr(val)

    with path.open('wt', encoding='utf-8') as fl:
        fl.write(f'"""{self.dataset.name} domains module"""')
        fl.write('\n\n')
        fl.write('from typing import Literal, TYPE_CHECKING')
        fl.write('\n\n')
        fl.write('if TYPE_CHECKING:\n')
        fl.write('    from arcpie._types import SystemDomain\n')
        fl.write('else:\n')
        fl.write('    SystemDomain = None\n')
        fl.write('\n\n')
        fl.write('DomainName = Literal[\n')
        for domain in _domains:
            fl.write(f"\n    '{domain}',")
        fl.write('\n]\n\n')
        fl.write('DOMAINS: dict[DomainName, SystemDomain] = {')
        for domain, domain_val in _domains.items():
            fl.write("\n"f"    '{domain}': ""{")
            fl.write(f"\n        'name': {_(domain_val['name'])},")
            fl.write(f"\n        'domainType': {_(domain_val['domainType'])},")
            fl.write("\n        'codedValues': {\n")
            if domain_val['codedValues']:
                fl.write('            ')
                fl.write('\n            '.join(f"'{k}': '{v}'," for k, v in domain_val['codedValues'].items()))
                fl.write('\n        },')
            else:
                fl.write('},')
            fl.write(f"\n        'range': {_(domain_val['range'])},")
            fl.write(f"\n        'type': {_(domain_val['type'])},")
            fl.write(f"\n        'description': {_(domain_val['description'])},")
            fl.write(f"\n        'splitPolicy': {_(domain_val['splitPolicy'])},")
            fl.write(f"\n        'mergePolicy': {_(domain_val['mergePolicy'])},")
            fl.write(f"\n        'owner': {_(domain_val['owner'])},")
            fl.write('\n    },')
        fl.write('\n}\n')

import_domains

import_domains(
    domains: dict[str, SystemDomain],
    *,
    overwrite: bool = False,
) -> None

Import domains from a domain mapping (DOMAINS global in exported module)

Source code in src/arcpie/schema/domain.py

def import_domains(self, domains: dict[str, SystemDomain], *, overwrite: bool = False) -> None:
    """Import domains from a domain mapping (DOMAINS global in exported module)"""

    for d_name, d_vals in domains.items():
        if d_name in self:
            if overwrite:
                self[d_name].delete()
            else:
                continue
        if d_vals['domainType'] == 'CodedValue':
            dom = CodedValueDomain.from_dict(d_vals, self.workspace)       
        elif d_vals['domainType'] == 'Range':
            dom = RangeDomain.from_dict(d_vals, self.workspace)
        else:
            raise ValueError(f'Invalid domain type {d_vals["domainType"]}')
        dom.add_to(self.dataset)

to_dict

to_dict() -> dict[str, DomainSchema]

Use with json.dump/dumps

Source code in src/arcpie/schema/domain.py

def to_dict(self) -> dict[str, DomainSchema]:
    """Use with json.dump/dumps"""
    return {d.name: d.to_dict() for d in self.domains}

usage

usage(*domain_names: str) -> DomainUsageMap

A mapping of domains to features to fields that shows usage of a domain in a dataset

PARAMETER	DESCRIPTION
*domain_names	Varargs of all domain names to include in the output mapping TYPE: str DEFAULT: ()

RETURNS	DESCRIPTION
DomainUsageMap	A Nested mapping of Domain Name -> Feature Class -> [Field Name, ...]

Source code in src/arcpie/schema/domain.py

def usage(self, *domain_names: str) -> DomainUsageMap:
    """A mapping of domains to features to fields that shows usage of a domain in a dataset

    Args:
        *domain_names: Varargs of all domain names to include in the output mapping

    Returns:
        A Nested mapping of `Domain Name -> Feature Class -> [Field Name, ...]`
    """

    if not domain_names:
        domain_names = tuple(self.domain_names)

    schema = self.dataset.schema
    fc_usage: DomainUsageMap = {}
    for dataset in schema['datasets']:
        features = dataset.get('datasets') or [dataset]
        for feature in features:
            if 'fields' not in feature:
                continue
            for field in feature['fields']['fieldArray']:
                if 'domain' not in field:
                    continue
                field_domain = field['domain']['domainName']
                fc_usage.setdefault(field_domain, {})
                if field_domain in domain_names:
                    fc_usage[field_domain].setdefault(feature['name'], [])
                    fc_usage[field_domain][feature['name']].append(field.get('name', '...'))
    return fc_usage

RangeDomain

RangeDomain(
    wrapped: Domain, workspace: str | Path | Dataset
)

Bases: Domain

Domain with a Range component

Returned by:

• Modules Domain
  •  CodedValueDomain  create
  •  Domain  create
  •  RangeDomain  create

METHOD	DESCRIPTION
add_to	Add the domain to a root workspace/Dataset
assign_to	Assign the domain to a Field
create	Create a new domain
delete	Delete the domain
from_dict	Create a Domain object from a system domain definition
from_table	Create a CodedValue domain from a Table
sort	CodedValue Only
sync	Sync the domain with the workspace
to_dict	Use with json.dump/dumps
to_table	Convert the domain to a Table in its workspace
used_by	Get a mapping of FeatureClass/Table -> [Field, ...] usage for the domain

Source code in src/arcpie/schema/domain.py

def __init__(self, wrapped: da.Domain, workspace: str | Path | Dataset) -> None:
    from ..database import Dataset
    self._domain = wrapped
    if not isinstance(workspace, Dataset):
        self.dataset = Dataset(workspace)
        self.workspace = str(workspace)
    else:
        self.dataset = workspace
        self.workspace = str(workspace)

add_to

add_to(workspace: Dataset) -> None

Add the domain to a root workspace/Dataset

Source code in src/arcpie/schema/domain.py

def add_to(self, workspace: Dataset) -> None:
    """Add the domain to a root workspace/Dataset"""
    if workspace.parent is not None:
        raise ValueError(f'Domains can only be added to the root Dataset!')
    CreateDomain(
        in_workspace=str(workspace.conn.resolve()), 
        domain_name=self.name, 
        domain_description=self.description,
        field_type=_DOMAIN_FIELD_TYPE_MAP[self.type],
        domain_type=_DOMAIN_TYPE_MAP[self.domainType],
        split_policy=_DOMAIN_SPLIT_POLICY_MAP[self.splitPolicy],
        merge_policy=_DOMAIN_MERGE_POLICY_MAP[self.mergePolicy],
    )
    if isinstance(self, CodedValueDomain):
        for code, value in self.codedValues.items():
            AddCodedValueToDomain(str(workspace), self.name, code, value)
    if isinstance(self, RangeDomain):
        SetValueForRangeDomain(str(workspace), self.name, *self.range)

assign_to

assign_to(
    table: Table | FeatureClass,
    field: str,
    *,
    subtype_code: int | None = None,
) -> None

Assign the domain to a Field

PARAMETER	DESCRIPTION
table	The table to apply the domain to TYPE: Table | FeatureClass
field	The field in the table to apply the domain to TYPE: str
subtype_code	An optional subtype to apply the domain to TYPE: int | None DEFAULT: None

Source code in src/arcpie/schema/domain.py

def assign_to(self, table: Table | FeatureClass, field: str,
             *,
             subtype_code: int | None = None,
             ) -> None:
    """Assign the domain to a Field

    Args:
        table: The table to apply the domain to
        field: The field in the table to apply the domain to
        subtype_code: An optional subtype to apply the domain to
    """
    field_info = table.field_defs.get(field)
    if not field_info:
        raise ValueError(f'{table.name}: {field} not found!')
    if field_info.get('field_type') not in VALID_FIELD_TYPES_FOR.get(self.type, set()):
        msg = (
            f'Domain of type {self.type} cannot be assigned to '
            f'field {field} of type {field_info.get('field_type')}'
        )
        raise ValueError(msg)

    AssignDomainToField(
        in_table=str(table),
        field_name=field,
        domain_name=self.name,
        subtype_code=subtype_code,
    )

create classmethod

create(
    workspace: str,
    name: str,
    *,
    domain_type: Literal["CodedValue"],
    field_type: DomainFieldType,
    coded_values: CodedValues,
    description: str,
    split_policy: SplitPolicy = ...,
    merge_policy: MergePolicy = ...,
) -> CodedValueDomain

create(
    workspace: str,
    name: str,
    *,
    domain_type: Literal["Range"],
    field_type: DomainFieldType,
    domain_range: RangeValue,
    description: str,
    split_policy: SplitPolicy = ...,
    merge_policy: MergePolicy = ...,
) -> RangeDomain

create(
    workspace: str,
    name: str,
    *,
    domain_type: DomainType,
    field_type: DomainFieldType,
    description: str = "",
    split_policy: SplitPolicy = "Duplicate",
    merge_policy: MergePolicy = "DefaultValue",
    domain_range: RangeValue | None = None,
    coded_values: CodedValues | None = None,
) -> CodedValueDomain | RangeDomain

Create a new domain

Source code in src/arcpie/schema/domain.py

@classmethod
def create(cls, workspace: str, name: str, 
           *,
           domain_type: DomainType,
           field_type: DomainFieldType,
           description: str = '', 
           split_policy: SplitPolicy = 'Duplicate',
           merge_policy: MergePolicy = 'DefaultValue',

           # Required by overload
           domain_range: RangeValue | None = None,
           coded_values: CodedValues | None = None) -> CodedValueDomain | RangeDomain:
    """Create a new domain"""
    assert domain_type in ['CodedValue', 'Range'], f'Invalid domain type {domain_type}'

    CreateDomain(
        in_workspace=workspace,
        domain_name=name,
        domain_description=description,
        field_type=_DOMAIN_FIELD_TYPE_MAP.get(field_type),
        domain_type=_DOMAIN_TYPE_MAP.get(domain_type),
        split_policy=_DOMAIN_SPLIT_POLICY_MAP.get(split_policy),
        merge_policy=_DOMAIN_MERGE_POLICY_MAP.get(merge_policy),
    )
    new_domain, *_ = [d for d in da.ListDomains(workspace) if d.name == name] or [None]
    if new_domain is None:
        raise ValueError(f'Something went wrong creating the Domain...')
    if domain_type == 'CodedValue':
        domain = CodedValueDomain(new_domain, workspace)
        if coded_values:
            domain.codedValues = {k: v for k, v in coded_values.items()}
        return domain
    elif domain_type == 'Range':
        domain = RangeDomain(new_domain, workspace)
        if domain_range:
            domain.range = domain_range
        return domain

delete

delete() -> None

Delete the domain

Source code in src/arcpie/schema/domain.py

def delete(self) -> None:
    """Delete the domain"""
    DeleteDomain(self.workspace, self.name)

from_dict classmethod

from_dict(
    definition: SystemDomain, workspace: str | None = None
) -> Domain

Create a Domain object from a system domain definition

Source code in src/arcpie/schema/domain.py

@classmethod
def from_dict(cls, definition: SystemDomain, workspace: str| None = None) -> Domain:
    """Create a Domain object from a system domain definition"""
    dom: da.Domain = type(f'__domain', (object,), {k: v for k,v in definition.items()})
    return cls(dom, workspace)

from_table classmethod

from_table(
    table: FeatureClass | Table,
    name: str,
    *,
    code_field: str,
    description_field: str,
    workspace: str | None = None,
    description: str | None,
    overwrite_existing: bool = False,
) -> CodedValueDomain

Create a CodedValue domain from a Table

PARAMETER	DESCRIPTION
table	The table or featureclass to create the domain from TYPE: FeatureClass | Table
name	The name of the domain TYPE: str
code_field	The field to use for codes TYPE: str
description_field	The field to use for descriptions TYPE: str
workspace	The workspace to create the domain in (default: table.workspace) TYPE: str | None DEFAULT: None
description	An optional description for the new domain TYPE: str | None
overwrite_existing	If set to True, any existing domains with the name will be replaced, otherwise new values are appended to the existing domain TYPE: bool DEFAULT: False

Source code in src/arcpie/schema/domain.py

@classmethod
def from_table(cls, table: FeatureClass | Table, name: str,
               *,
               code_field: str,
               description_field: str,
               workspace: str | None = None,
               description: str | None,
               overwrite_existing: bool = False,
               ) -> CodedValueDomain:
    """Create a CodedValue domain from a Table

    Args:
        table: The table or featureclass to create the domain from
        name: The name of the domain
        code_field: The field to use for codes
        description_field: The field to use for descriptions
        workspace: The workspace to create the domain in (default: table.workspace)
        description: An optional description for the new domain
        overwrite_existing: If set to `True`, any existing domains with the name will be replaced,<br> 
            otherwise new values are appended to the existing domain
    """
    if code_field not in table.fields or description_field not in table.fields:
        msg = (
            f'Invalid {code_field} or {description_field} not in table fields, '
            f'must be one of {table.fields}'
        )
        raise ValueError(msg)

    workspace = workspace or table.workspace
    TableToDomain(
        in_table=str(table),
        code_field=code_field,
        description_field=description_field,
        in_workspace=workspace or table.workspace,
        domain_name=name,
        domain_description=description,
        update_option='REPLACE' if overwrite_existing else 'APPEND'
    )
    return CodedValueDomain([d for d in da.ListDomains(workspace) if d.name == name].pop(), workspace)

sort

sort(
    by: Literal["code", "value"],
    order: Literal["asc", "desc"],
) -> None

CodedValue Only

Source code in src/arcpie/schema/domain.py

def sort(self, by: Literal['code', 'value'], order: Literal['asc', 'desc']) -> None:
    """CodedValue Only"""

sync

sync() -> None

Sync the domain with the workspace

Source code in src/arcpie/schema/domain.py

def sync(self) -> None:
    """Sync the domain with the workspace"""
    matches = [d for d in da.ListDomains(self.workspace) if d.name == self.name]
    if not matches:
        raise LookupError(f'Domain {self.name} no longer exists in the parent workspace {self.workspace}')
    self._domain = matches.pop()

to_dict

to_dict() -> DomainSchema

Use with json.dump/dumps

Source code in src/arcpie/schema/domain.py

def to_dict(self) -> DomainSchema:
    """Use with json.dump/dumps"""
    return {
        'name': self.name,
        'domainType': self.domainType,
        'type': self.type,
        'description': self.description,
        'codedValues': self.codedValues,
        'range': self.range,
        'mergePolicy': self.mergePolicy,
        'splitPolicy': self.splitPolicy,
        'owner': self.owner,
    }

to_table

to_table(
    table_name: str,
    *,
    code_field: str = "code",
    description_field: str = "description",
    configuration_keyword: str | None = None,
) -> Table

Convert the domain to a Table in its workspace

PARAMETER	DESCRIPTION
table_name	The name of the output table TYPE: str
code_field	The field name for the codes TYPE: str DEFAULT: 'code'
description_field	The field name for the descriptions TYPE: str DEFAULT: 'description'
configuration_keyword	An optional config keyword for the database TYPE: str | None DEFAULT: None

Source code in src/arcpie/schema/domain.py

def to_table(self, table_name: str, 
             *,
             code_field: str = 'code',
             description_field: str = 'description',
             configuration_keyword: str | None = None
             ) -> Table:
    """Convert the domain to a Table in its workspace

    Args:
        table_name: The name of the output table
        code_field: The field name for the codes
        description_field: The field name for the descriptions
        configuration_keyword: An optional config keyword for the database
    """
    if self.domainType != 'CodedValue':
        raise TypeError(f'Only `CodedValue` domains can be converted to a table')
    return Table(
        *DomainToTable(
            in_workspace=self.workspace, 
            domain_name=self.name, 
            out_table=table_name,
            code_field=code_field,
            description_field=description_field,
            configuration_keyword=configuration_keyword,
        )
    )

used_by

used_by() -> FieldUsage

Get a mapping of FeatureClass/Table -> [Field, ...] usage for the domain

Source code in src/arcpie/schema/domain.py

def used_by(self) -> FieldUsage:
    """Get a mapping of FeatureClass/Table -> [Field, ...] usage for the domain"""
    return self.dataset.domains.usage(self.name)[self.name]

map_args

map_args(fr: Any, to: Any) -> dict[Any, Any]

Map two literals

Source code in src/arcpie/schema/domain.py

def map_args(fr: Any, to: Any) -> dict[Any, Any]:
    """Map two literals"""
    return dict(zip(get_args(fr), get_args(to)))