Non-dataclass alternatives to this code

[dmos62]

Previously discussed in: #913

Related to: #921

Here's an implementation of an abstract class Expression and a concrete subclass ColumnReference, both written using dataclasses:

from dataclasses import dataclass, field
from abc import ABC, abstractmethod
from collections.abc import Sequence

def frozen_dataclass(f):
    """
    Data class decorator with frozen set to True, which provides immutability.
    """
    return dataclass(frozen=True)(f)


def static(value):
    """
    Declares a static field on a dataclass.
    """
    return field(init=False, default=value)


@frozen_dataclass
class Expression(ABC):
    id: str
    name: str
    suggestions: Sequence = static(None)
    parameters: Sequence

    @staticmethod
    @abstractmethod
    def to_sa_expression():
        return None


@frozen_dataclass
class ColumnReference(Expression):
    id: str = static("column_reference")
    name: str = static("Column Reference")
    suggestions: Sequence = static(tuple([
        suggestions.parameter_count(1),
        suggestions.parameter(1, suggestions.column),
    ]))

    def column(self):
        return self.parameters[0]

    @staticmethod
    def to_sa_expression(p):
        return column(p)

Some of the requirements for the code above are:

• for the abstract class;
  • definition of what's required of subclasses;
• for the concrete subclasses;
  • static properties (namely, id, name, suggestions);
  • a static method (to_sa_expression);
  • an instance property (parameters);
  • immutability.

Here's one way to do this without dataclasses:

from abc import ABC, abstractmethod

class Expression(ABC):
    @staticmethod
    @abstractmethod
    def id():
        pass

    @staticmethod
    @abstractmethod
    def name():
        pass

    @staticmethod
    def suggestions():
        return None

    @staticmethod
    @abstractmethod
    def to_sa_expression():
        pass

    @property
    def parameters(self):
        try:
            return self._parameters
        except AttributeError:
            raise Exception("This expression was instantiated without parameters.")


class ColumnReference(Expression):
    @staticmethod
    def id():
        return "column_reference"

    @staticmethod
    def name():
        return "Column Reference"

    @staticmethod
    def to_sa_expression():
        return column(p)

    @staticmethod
    def suggestions():
        return tuple([
            suggestions.parameter_count(1),
            suggestions.parameter(1, suggestions.column),
        ])

    def __init__(self, parameters):
        self._parameters = parameters

@staticmethod is used for static properties, because there's no such thing as a static property per se in Python. The instance property is implemented using the "hidden" instance-level _parameters and the abstract-class-level parameters property that accesses it: that provides an immutable instance property and its abstract definition.

I'm not crazy about the non-dataclass variant above. Anyone care to try their hand at this?

I explored subclassing a namedtuple for this, but it didn't seem well suited for the task, though there might be a way.

[kgodey]

Some of the requirements for the code above are:

• for the abstract class;
  • definition of what's required of subclasses;
• for the concrete subclasses;
  • static properties (namely, id, name, suggestions);
  • a static method (to_sa_expression);
  • an instance property (parameters);
  • immutability.

I'm not sure all of these are requirements, I don't think we need all the static-ness and immutability. Here's how I would do it:

class Expression:
    id = None
    name = None

    def to_sa_expression():
        raise NotImplementedError('Expression subclasses should implement a to_sa_expression method')

    def suggestions():
        return ()

    def __init__(self, parameters):
        if self.id is None:
            raise ValueError('Expression subclasses should define an ID')
        if self.name is None:
            raise ValueError('Expression subclasses should define a name')
        self.parameters = parameters


class ColumnReference(Expression):
    id = 'column_reference'
    name = 'Column Reference'
    
    def to_sa_expression():
        return column(p)
    
    def suggestions():
        return (suggestions.parameter_count(1), suggestions.parameter(1, suggestions.column))

Note that I haven't run this code locally, since not all of it seems to be runnable (e.g. column(p))

[dmos62]

After seeing your code, I realised you're right about these not being requirements. Something like ColumnReference.id = "something else" is easy to catch in review.