class BaseAdapter(abc.ABC):

    def __init__(

class BaseResultORM(Base):

    __tablename__ = "base_result"

class ResultORM(BaseResultORM):

    __tablename__ = "result"

class ProcedureMixin:

    program = Column(String(100), nullable=False)

class OptimizationProcedureORM(ProcedureMixin, BaseResultORM):

    __tablename__ = "optimization_procedure"

class TorsionDriveProcedureORM(ProcedureMixin, BaseResultORM):

    __tablename__ = "torsiondrive_procedure"

    _required_auth = "read"

    def get(self):

        self.logger.info("GET: Information")

class ParslAdapter(BaseAdapter):

    def __init__(self, client: Any, logger: Optional[logging.Logger] = None, **kwargs):

        BaseAdapter.__init__(self, client, logger, **kwargs)

        id: QueryObjectId = Field(None, description="Id of the Key/Value Storage object to get.")

    meta: EmptyMeta = Field({}, description=common_docs[EmptyMeta])

class KVStoreGETResponse(ProtoModel):

            prog_default_kw = self.data.default_keywords.get(program, None)

            for kwalias, kwid in kwaliases.items():

                data.append(

        return pd.DataFrame(data).set_index("program")

class CollectionORM(Base):

    __tablename__ = "collection"

class DatasetMixin:

    default_benchmark = Column(String)

class ContributedValuesORM(Base):

    __tablename__ = "contributed_values"

class DatasetORM(CollectionORM, DatasetMixin):

    __tablename__ = "dataset"

class ReactionDatasetORM(CollectionORM, DatasetMixin):

    __tablename__ = "reaction_dataset"

    def update_services(self) -> int:

        current_services = self.storage.get_services(status="RUNNING")["data"]

class ExecutorAdapter(BaseAdapter):

    def __repr__(self):

class DaskAdapter(ExecutorAdapter):

    def __repr__(self):

    @validator("method")

        return v.lower()

    @validator("basis")

def provenance_stamp(routine):

    def _get_all_results(self, optimization_ids: List[Union[int, str]] = None):

        if optimization_ids is None:

@contextmanager

def reset_server_database(server):

    if "QCFRACTAL_RESET_TESTING_DB" in os.environ:

class MoleculeORM(Base):

    __tablename__ = "molecule"

class KeywordsORM(Base):

    __tablename__ = "keywords"

class TaskQueueORM(Base):

    __tablename__ = "task_queue"

class QueueManagerORM(Base):

    __tablename__ = "queue_manager"

class SQLAlchemySocket:

    def __init__(

    def get_limit(self, limit: Optional[int]) -> int:

        return limit if limit is not None and limit < self._max_limit else self._max_limit

            existing_results = {}

            for cond in conds:

                if doc is not None:

            for i, result in enumerate(record_list):

    def services_completed(self, records_list: List["BaseService"]) -> int:

    _required_auth = "compute"

    def post(self):

        body_model, response_model = rest_model("task_queue", "post")

        body = self.parse_bodymodel(body_model)

        self.write(response)

    def get(self):

        body_model, response_model = rest_model("task_queue", "get")

        body = self.parse_bodymodel(body_model)

        self.write(response)

    def put(self):

        body_model, response_model = rest_model("task_queue", "put")

        body = self.parse_bodymodel(body_model)

    _required_auth = "compute"

    def post(self):

        body_model, response_model = rest_model("service_queue", "post")

        body = self.parse_bodymodel(body_model)

        self.write(response)

    def get(self):

        body_model, response_model = rest_model("service_queue", "get")

        body = self.parse_bodymodel(body_model)

        self.write(response)

    def put(self):

        body_model, response_model = rest_model("service_queue", "put")

        body = self.parse_bodymodel(body_model)

        return len(completed), len(error_data)

    def get(self):

        body_model, response_model = rest_model("queue_manager", "get")

        body = self.parse_bodymodel(body_model)

        self.storage.manager_update(name, submitted=len(new_tasks), **body.meta.dict())

    def post(self):

        body_model, response_model = rest_model("queue_manager", "post")

        body = self.parse_bodymodel(body_model)

    _required_auth = "admin"

    def get(self):

        body_model, response_model = rest_model("manager", "get")

        body = self.parse_bodymodel(body_model)

        if isinstance(data, dict):

                raise ValueError("Compression is set, but input is a dictionary")

                raise ValueError("Compression level is set, but input is a dictionary")

            return json.dumps(data).encode()

        elif isinstance(data, str):

                raise ValueError("Compression is set, but input is a string")

                raise ValueError("Compression level is set, but input is a string")

            return data.encode()

            return compression_level

    @classmethod

        data = input_str.encode()

        elif compression_type is CompressionEnum.lzma:

            if compression_level is None:

                    compression_level = 6

        return cls(data=data, compression=compression_type, compression_level=compression_level)

    def get_string(self):

    def get_json(self):

class SingleResultTasks(BaseTasks):

    def verify_input(self, data):

def import_module(module, package=None):

    try:

        ret = importlib.import_module(module, package=package)

def read_config_file(fname):

    if fname.endswith(".yaml") or fname.endswith(".yml"):

        try:

            rfunc = partial(yaml.load, Loader=yaml.FullLoader)