lomas_server.utils package
Submodules
lomas_server.utils.anti_timing_att module
lomas_server.utils.collection_models module
- class lomas_server.utils.collection_models.Dataset(*, dataset_name: str, metadata: MetadataOfPathDB | MetadataOfS3DB)[source]
Bases:
BaseModel
BaseModel for a dataset
- dataset_name: str
- metadata: MetadataOfPathDB | MetadataOfS3DB
- model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}
A dictionary of computed field names and their corresponding ComputedFieldInfo objects.
- model_config: ClassVar[ConfigDict] = {}
Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].
- model_fields: ClassVar[dict[str, FieldInfo]] = {'dataset_name': FieldInfo(annotation=str, required=True), 'metadata': FieldInfo(annotation=Union[MetadataOfPathDB, MetadataOfS3DB], required=True, discriminator='database_type')}
Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].
This replaces Model.__fields__ from Pydantic V1.
- class lomas_server.utils.collection_models.DatasetOfPathDB(*, dataset_name: str, metadata: MetadataOfPathDB | MetadataOfS3DB, database_type: Literal[PrivateDatabaseType.PATH], dataset_path: str)[source]
Bases:
Dataset
BaseModel for a local dataset
- database_type: Literal[PrivateDatabaseType.PATH]
- dataset_path: str
- model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}
A dictionary of computed field names and their corresponding ComputedFieldInfo objects.
- model_config: ClassVar[ConfigDict] = {}
Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].
- model_fields: ClassVar[dict[str, FieldInfo]] = {'database_type': FieldInfo(annotation=Literal[<PrivateDatabaseType.PATH: 'PATH_DB'>], required=True), 'dataset_name': FieldInfo(annotation=str, required=True), 'dataset_path': FieldInfo(annotation=str, required=True), 'metadata': FieldInfo(annotation=Union[MetadataOfPathDB, MetadataOfS3DB], required=True, discriminator='database_type')}
Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].
This replaces Model.__fields__ from Pydantic V1.
- class lomas_server.utils.collection_models.DatasetOfS3DB(*, dataset_name: str, metadata: MetadataOfPathDB | MetadataOfS3DB, database_type: Literal[PrivateDatabaseType.S3], endpoint_url: str, bucket: str, key: str, credentials_name: str)[source]
Bases:
Dataset
BaseModel for a dataset on S3
- bucket: str
- credentials_name: str
- database_type: Literal[PrivateDatabaseType.S3]
- endpoint_url: str
- key: str
- model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}
A dictionary of computed field names and their corresponding ComputedFieldInfo objects.
- model_config: ClassVar[ConfigDict] = {}
Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].
- model_fields: ClassVar[dict[str, FieldInfo]] = {'bucket': FieldInfo(annotation=str, required=True), 'credentials_name': FieldInfo(annotation=str, required=True), 'database_type': FieldInfo(annotation=Literal[<PrivateDatabaseType.S3: 'S3_DB'>], required=True), 'dataset_name': FieldInfo(annotation=str, required=True), 'endpoint_url': FieldInfo(annotation=str, required=True), 'key': FieldInfo(annotation=str, required=True), 'metadata': FieldInfo(annotation=Union[MetadataOfPathDB, MetadataOfS3DB], required=True, discriminator='database_type')}
Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].
This replaces Model.__fields__ from Pydantic V1.
- class lomas_server.utils.collection_models.DatasetOfUser(*, dataset_name: str, initial_epsilon: float, initial_delta: float, total_spent_epsilon: float, total_spent_delta: float)[source]
Bases:
BaseModel
BaseModel for informations of a user on a dataset
- dataset_name: str
- initial_delta: float
- initial_epsilon: float
- model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}
A dictionary of computed field names and their corresponding ComputedFieldInfo objects.
- model_config: ClassVar[ConfigDict] = {}
Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].
- model_fields: ClassVar[dict[str, FieldInfo]] = {'dataset_name': FieldInfo(annotation=str, required=True), 'initial_delta': FieldInfo(annotation=float, required=True), 'initial_epsilon': FieldInfo(annotation=float, required=True), 'total_spent_delta': FieldInfo(annotation=float, required=True), 'total_spent_epsilon': FieldInfo(annotation=float, required=True)}
Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].
This replaces Model.__fields__ from Pydantic V1.
- total_spent_delta: float
- total_spent_epsilon: float
- class lomas_server.utils.collection_models.DatasetsCollection(*, datasets: List[DatasetOfPathDB | DatasetOfS3DB])[source]
Bases:
BaseModel
BaseModel for datasets collection
- datasets: List[DatasetOfPathDB | DatasetOfS3DB]
- model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}
A dictionary of computed field names and their corresponding ComputedFieldInfo objects.
- model_config: ClassVar[ConfigDict] = {}
Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].
- model_fields: ClassVar[dict[str, FieldInfo]] = {'datasets': FieldInfo(annotation=List[Union[DatasetOfPathDB, DatasetOfS3DB]], required=True, discriminator='database_type')}
Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].
This replaces Model.__fields__ from Pydantic V1.
- class lomas_server.utils.collection_models.Metadata(*, max_ids: int, row_privacy: bool, censor_dims: bool | None = False, columns: Dict[str, Dict[str, int | float | str | List[str]]])[source]
Bases:
BaseModel
BaseModel for a metadata format
- censor_dims: bool | None
- columns: Dict[str, Dict[str, int | float | str | List[str]]]
- max_ids: int
- model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}
A dictionary of computed field names and their corresponding ComputedFieldInfo objects.
- model_config: ClassVar[ConfigDict] = {}
Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].
- model_fields: ClassVar[dict[str, FieldInfo]] = {'censor_dims': FieldInfo(annotation=Union[bool, NoneType], required=False, default=False), 'columns': FieldInfo(annotation=Dict[str, Dict[str, Union[int, float, str, List[str]]]], required=True), 'max_ids': FieldInfo(annotation=int, required=True), 'row_privacy': FieldInfo(annotation=bool, required=True)}
Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].
This replaces Model.__fields__ from Pydantic V1.
- row_privacy: bool
- class lomas_server.utils.collection_models.MetadataOfDataset[source]
Bases:
BaseModel
BaseModel for metadata of a dataset
- model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}
A dictionary of computed field names and their corresponding ComputedFieldInfo objects.
- model_config: ClassVar[ConfigDict] = {}
Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].
- model_fields: ClassVar[dict[str, FieldInfo]] = {}
Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].
This replaces Model.__fields__ from Pydantic V1.
- class lomas_server.utils.collection_models.MetadataOfPathDB(*, database_type: Literal[PrivateDatabaseType.PATH], metadata_path: str)[source]
Bases:
MetadataOfDataset
BaseModel for metadata of a dataset with PATH_DB
- database_type: Literal[PrivateDatabaseType.PATH]
- metadata_path: str
- model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}
A dictionary of computed field names and their corresponding ComputedFieldInfo objects.
- model_config: ClassVar[ConfigDict] = {}
Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].
- model_fields: ClassVar[dict[str, FieldInfo]] = {'database_type': FieldInfo(annotation=Literal[<PrivateDatabaseType.PATH: 'PATH_DB'>], required=True), 'metadata_path': FieldInfo(annotation=str, required=True)}
Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].
This replaces Model.__fields__ from Pydantic V1.
- class lomas_server.utils.collection_models.MetadataOfS3DB(*, database_type: Literal[PrivateDatabaseType.S3], endpoint_url: str, bucket: str, key: str, access_key_id: str | None = None, secret_access_key: str | None = None, credentials_name: str)[source]
Bases:
MetadataOfDataset
BaseModel for metadata of a dataset with S3_DB
- access_key_id: str | None
- bucket: str
- credentials_name: str
- database_type: Literal[PrivateDatabaseType.S3]
- endpoint_url: str
- key: str
- model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}
A dictionary of computed field names and their corresponding ComputedFieldInfo objects.
- model_config: ClassVar[ConfigDict] = {}
Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].
- model_fields: ClassVar[dict[str, FieldInfo]] = {'access_key_id': FieldInfo(annotation=Union[str, NoneType], required=False, default=None), 'bucket': FieldInfo(annotation=str, required=True), 'credentials_name': FieldInfo(annotation=str, required=True), 'database_type': FieldInfo(annotation=Literal[<PrivateDatabaseType.S3: 'S3_DB'>], required=True), 'endpoint_url': FieldInfo(annotation=str, required=True), 'key': FieldInfo(annotation=str, required=True), 'secret_access_key': FieldInfo(annotation=Union[str, NoneType], required=False, default=None)}
Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].
This replaces Model.__fields__ from Pydantic V1.
- secret_access_key: str | None
- class lomas_server.utils.collection_models.User(*, user_name: str, may_query: bool, datasets_list: List[DatasetOfUser])[source]
Bases:
BaseModel
BaseModel for a user in a user collection
- datasets_list: List[DatasetOfUser]
- may_query: bool
- model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}
A dictionary of computed field names and their corresponding ComputedFieldInfo objects.
- model_config: ClassVar[ConfigDict] = {}
Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].
- model_fields: ClassVar[dict[str, FieldInfo]] = {'datasets_list': FieldInfo(annotation=List[DatasetOfUser], required=True), 'may_query': FieldInfo(annotation=bool, required=True), 'user_name': FieldInfo(annotation=str, required=True)}
Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].
This replaces Model.__fields__ from Pydantic V1.
- user_name: str
- class lomas_server.utils.collection_models.UserCollection(*, users: List[User])[source]
Bases:
BaseModel
BaseModel for users collection
- model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}
A dictionary of computed field names and their corresponding ComputedFieldInfo objects.
- model_config: ClassVar[ConfigDict] = {}
Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].
- model_fields: ClassVar[dict[str, FieldInfo]] = {'users': FieldInfo(annotation=List[User], required=True)}
Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].
This replaces Model.__fields__ from Pydantic V1.
lomas_server.utils.config module
lomas_server.utils.error_handler module
lomas_server.utils.logger module
lomas_server.utils.query_examples module
lomas_server.utils.query_models module
- class lomas_server.utils.query_models.DiffPrivLibModel(*, dataset_name: str, diffprivlib_json: str, feature_columns: list, target_columns: list | None, test_size: Annotated[float, Gt(gt=0.0), Lt(lt=1.0)], test_train_split_seed: int, imputer_strategy: str)[source]
Bases:
BaseModel
Model input for a diffprivlib query
- dataset_name: str
- diffprivlib_json: str
- feature_columns: list
- imputer_strategy: str
- model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}
A dictionary of computed field names and their corresponding ComputedFieldInfo objects.
- model_config: ClassVar[ConfigDict] = {}
Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].
- model_fields: ClassVar[dict[str, FieldInfo]] = {'dataset_name': FieldInfo(annotation=str, required=True), 'diffprivlib_json': FieldInfo(annotation=str, required=True), 'feature_columns': FieldInfo(annotation=list, required=True), 'imputer_strategy': FieldInfo(annotation=str, required=True), 'target_columns': FieldInfo(annotation=Union[list, NoneType], required=True), 'test_size': FieldInfo(annotation=float, required=True, metadata=[Gt(gt=0.0), Lt(lt=1.0)]), 'test_train_split_seed': FieldInfo(annotation=int, required=True)}
Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].
This replaces Model.__fields__ from Pydantic V1.
- target_columns: list | None
- test_size: float
- test_train_split_seed: int
- class lomas_server.utils.query_models.DummyDiffPrivLibModel(*, dataset_name: str, diffprivlib_json: str, feature_columns: list, target_columns: list | None, test_size: Annotated[float, Gt(gt=0.0), Lt(lt=1.0)], test_train_split_seed: int, imputer_strategy: str, dummy_nb_rows: Annotated[int, Gt(gt=0)], dummy_seed: int)[source]
Bases:
BaseModel
Model input for a dummy diffprivlib query
- dataset_name: str
- diffprivlib_json: str
- dummy_nb_rows: int
- dummy_seed: int
- feature_columns: list
- imputer_strategy: str
- model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}
A dictionary of computed field names and their corresponding ComputedFieldInfo objects.
- model_config: ClassVar[ConfigDict] = {}
Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].
- model_fields: ClassVar[dict[str, FieldInfo]] = {'dataset_name': FieldInfo(annotation=str, required=True), 'diffprivlib_json': FieldInfo(annotation=str, required=True), 'dummy_nb_rows': FieldInfo(annotation=int, required=True, metadata=[Gt(gt=0)]), 'dummy_seed': FieldInfo(annotation=int, required=True), 'feature_columns': FieldInfo(annotation=list, required=True), 'imputer_strategy': FieldInfo(annotation=str, required=True), 'target_columns': FieldInfo(annotation=Union[list, NoneType], required=True), 'test_size': FieldInfo(annotation=float, required=True, metadata=[Gt(gt=0.0), Lt(lt=1.0)]), 'test_train_split_seed': FieldInfo(annotation=int, required=True)}
Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].
This replaces Model.__fields__ from Pydantic V1.
- target_columns: list | None
- test_size: float
- test_train_split_seed: int
- class lomas_server.utils.query_models.DummyOpenDPModel(*, dataset_name: str, opendp_json: str, dummy_nb_rows: Annotated[int, Gt(gt=0)], dummy_seed: int, fixed_delta: float | None = None)[source]
Bases:
BaseModel
Model input for a dummy opendp query
- dataset_name: str
- dummy_nb_rows: int
- dummy_seed: int
- fixed_delta: float | None
- model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}
A dictionary of computed field names and their corresponding ComputedFieldInfo objects.
- model_config: ClassVar[ConfigDict] = {}
Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].
- model_fields: ClassVar[dict[str, FieldInfo]] = {'dataset_name': FieldInfo(annotation=str, required=True), 'dummy_nb_rows': FieldInfo(annotation=int, required=True, metadata=[Gt(gt=0)]), 'dummy_seed': FieldInfo(annotation=int, required=True), 'fixed_delta': FieldInfo(annotation=Union[float, NoneType], required=False, default=None), 'opendp_json': FieldInfo(annotation=str, required=True)}
Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].
This replaces Model.__fields__ from Pydantic V1.
- opendp_json: str
- class lomas_server.utils.query_models.DummySmartnoiseSQLModel(*, query_str: str, dataset_name: str, dummy_nb_rows: Annotated[int, Gt(gt=0)], dummy_seed: int, epsilon: Annotated[float, Gt(gt=0)], delta: Annotated[float, Gt(gt=0)], mechanisms: dict, postprocess: bool)[source]
Bases:
BaseModel
Model input for a smarnoise-sql dummy query
- dataset_name: str
- delta: float
- dummy_nb_rows: int
- dummy_seed: int
- epsilon: float
- mechanisms: dict
- model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}
A dictionary of computed field names and their corresponding ComputedFieldInfo objects.
- model_config: ClassVar[ConfigDict] = {}
Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].
- model_fields: ClassVar[dict[str, FieldInfo]] = {'dataset_name': FieldInfo(annotation=str, required=True), 'delta': FieldInfo(annotation=float, required=True, metadata=[Gt(gt=0)]), 'dummy_nb_rows': FieldInfo(annotation=int, required=True, metadata=[Gt(gt=0)]), 'dummy_seed': FieldInfo(annotation=int, required=True), 'epsilon': FieldInfo(annotation=float, required=True, metadata=[Gt(gt=0)]), 'mechanisms': FieldInfo(annotation=dict, required=True), 'postprocess': FieldInfo(annotation=bool, required=True), 'query_str': FieldInfo(annotation=str, required=True)}
Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].
This replaces Model.__fields__ from Pydantic V1.
- postprocess: bool
- query_str: str
- class lomas_server.utils.query_models.DummySmartnoiseSynthQueryModel(*, dataset_name: str, synth_name: SSynthMarginalSynthesizer | SSynthGanSynthesizer, epsilon: Annotated[float, Gt(gt=0), Le(le=5.0)], delta: float | None = None, select_cols: List, synth_params: dict, nullable: bool, constraints: str, return_model: bool, condition: str, nb_samples: int, dummy_nb_rows: Annotated[int, Gt(gt=0)], dummy_seed: int)[source]
Bases:
SmartnoiseSynthQueryModel
Dummy Model input for a smarnoise-synth query
- dummy_nb_rows: int
- dummy_seed: int
- model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}
A dictionary of computed field names and their corresponding ComputedFieldInfo objects.
- model_config: ClassVar[ConfigDict] = {}
Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].
- model_fields: ClassVar[dict[str, FieldInfo]] = {'condition': FieldInfo(annotation=str, required=True), 'constraints': FieldInfo(annotation=str, required=True), 'dataset_name': FieldInfo(annotation=str, required=True), 'delta': FieldInfo(annotation=Union[float, NoneType], required=False, default=None), 'dummy_nb_rows': FieldInfo(annotation=int, required=True, metadata=[Gt(gt=0)]), 'dummy_seed': FieldInfo(annotation=int, required=True), 'epsilon': FieldInfo(annotation=float, required=True, metadata=[Gt(gt=0), Le(le=5.0)]), 'nb_samples': FieldInfo(annotation=int, required=True), 'nullable': FieldInfo(annotation=bool, required=True), 'return_model': FieldInfo(annotation=bool, required=True), 'select_cols': FieldInfo(annotation=List, required=True), 'synth_name': FieldInfo(annotation=Union[SSynthMarginalSynthesizer, SSynthGanSynthesizer], required=True), 'synth_params': FieldInfo(annotation=dict, required=True)}
Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].
This replaces Model.__fields__ from Pydantic V1.
- class lomas_server.utils.query_models.GetDbData(*, dataset_name: str)[source]
Bases:
BaseModel
Model input to get information about a dataset
- dataset_name: str
- model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}
A dictionary of computed field names and their corresponding ComputedFieldInfo objects.
- model_config: ClassVar[ConfigDict] = {}
Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].
- model_fields: ClassVar[dict[str, FieldInfo]] = {'dataset_name': FieldInfo(annotation=str, required=True)}
Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].
This replaces Model.__fields__ from Pydantic V1.
- class lomas_server.utils.query_models.GetDummyDataset(*, dataset_name: str, dummy_nb_rows: Annotated[int, Gt(gt=0)], dummy_seed: int)[source]
Bases:
BaseModel
Model input to get a dummy dataset
- dataset_name: str
- dummy_nb_rows: int
- dummy_seed: int
- model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}
A dictionary of computed field names and their corresponding ComputedFieldInfo objects.
- model_config: ClassVar[ConfigDict] = {}
Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].
- model_fields: ClassVar[dict[str, FieldInfo]] = {'dataset_name': FieldInfo(annotation=str, required=True), 'dummy_nb_rows': FieldInfo(annotation=int, required=True, metadata=[Gt(gt=0)]), 'dummy_seed': FieldInfo(annotation=int, required=True)}
Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].
This replaces Model.__fields__ from Pydantic V1.
- class lomas_server.utils.query_models.OpenDPModel(*, dataset_name: str, opendp_json: str, fixed_delta: float | None = None)[source]
Bases:
BaseModel
Model input for an opendp query
- dataset_name: str
- fixed_delta: float | None
- model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}
A dictionary of computed field names and their corresponding ComputedFieldInfo objects.
- model_config: ClassVar[ConfigDict] = {}
Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].
- model_fields: ClassVar[dict[str, FieldInfo]] = {'dataset_name': FieldInfo(annotation=str, required=True), 'fixed_delta': FieldInfo(annotation=Union[float, NoneType], required=False, default=None), 'opendp_json': FieldInfo(annotation=str, required=True)}
Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].
This replaces Model.__fields__ from Pydantic V1.
- opendp_json: str
- class lomas_server.utils.query_models.SmartnoiseSQLCostModel(*, query_str: str, dataset_name: str, epsilon: Annotated[float, Gt(gt=0)], delta: Annotated[float, Gt(gt=0)], mechanisms: dict)[source]
Bases:
BaseModel
Model input for a smarnoise-sql cost query
- dataset_name: str
- delta: float
- epsilon: float
- mechanisms: dict
- model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}
A dictionary of computed field names and their corresponding ComputedFieldInfo objects.
- model_config: ClassVar[ConfigDict] = {}
Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].
- model_fields: ClassVar[dict[str, FieldInfo]] = {'dataset_name': FieldInfo(annotation=str, required=True), 'delta': FieldInfo(annotation=float, required=True, metadata=[Gt(gt=0)]), 'epsilon': FieldInfo(annotation=float, required=True, metadata=[Gt(gt=0)]), 'mechanisms': FieldInfo(annotation=dict, required=True), 'query_str': FieldInfo(annotation=str, required=True)}
Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].
This replaces Model.__fields__ from Pydantic V1.
- query_str: str
- class lomas_server.utils.query_models.SmartnoiseSQLModel(*, query_str: str, dataset_name: str, epsilon: Annotated[float, Gt(gt=0), Le(le=5.0)], delta: Annotated[float, Gt(gt=0), Le(le=0.0004)], mechanisms: dict, postprocess: bool)[source]
Bases:
BaseModel
Model input for a smarnoise-sql query
- dataset_name: str
- delta: float
- epsilon: float
- mechanisms: dict
- model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}
A dictionary of computed field names and their corresponding ComputedFieldInfo objects.
- model_config: ClassVar[ConfigDict] = {}
Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].
- model_fields: ClassVar[dict[str, FieldInfo]] = {'dataset_name': FieldInfo(annotation=str, required=True), 'delta': FieldInfo(annotation=float, required=True, metadata=[Gt(gt=0), Le(le=0.0004)]), 'epsilon': FieldInfo(annotation=float, required=True, metadata=[Gt(gt=0), Le(le=5.0)]), 'mechanisms': FieldInfo(annotation=dict, required=True), 'postprocess': FieldInfo(annotation=bool, required=True), 'query_str': FieldInfo(annotation=str, required=True)}
Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].
This replaces Model.__fields__ from Pydantic V1.
- postprocess: bool
- query_str: str
- class lomas_server.utils.query_models.SmartnoiseSynthCostModel(*, dataset_name: str, synth_name: SSynthMarginalSynthesizer | SSynthGanSynthesizer, epsilon: Annotated[float, Gt(gt=0), Le(le=5.0)], delta: float | None = None, select_cols: List, synth_params: dict, nullable: bool, constraints: str)[source]
Bases:
BaseModel
Model input for a smarnoise-synth cost
- constraints: str
- dataset_name: str
- delta: float | None
- epsilon: float
- model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}
A dictionary of computed field names and their corresponding ComputedFieldInfo objects.
- model_config: ClassVar[ConfigDict] = {}
Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].
- model_fields: ClassVar[dict[str, FieldInfo]] = {'constraints': FieldInfo(annotation=str, required=True), 'dataset_name': FieldInfo(annotation=str, required=True), 'delta': FieldInfo(annotation=Union[float, NoneType], required=False, default=None), 'epsilon': FieldInfo(annotation=float, required=True, metadata=[Gt(gt=0), Le(le=5.0)]), 'nullable': FieldInfo(annotation=bool, required=True), 'select_cols': FieldInfo(annotation=List, required=True), 'synth_name': FieldInfo(annotation=Union[SSynthMarginalSynthesizer, SSynthGanSynthesizer], required=True), 'synth_params': FieldInfo(annotation=dict, required=True)}
Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].
This replaces Model.__fields__ from Pydantic V1.
- nullable: bool
- select_cols: List
- synth_name: SSynthMarginalSynthesizer | SSynthGanSynthesizer
- synth_params: dict
- class lomas_server.utils.query_models.SmartnoiseSynthQueryModel(*, dataset_name: str, synth_name: SSynthMarginalSynthesizer | SSynthGanSynthesizer, epsilon: Annotated[float, Gt(gt=0), Le(le=5.0)], delta: float | None = None, select_cols: List, synth_params: dict, nullable: bool, constraints: str, return_model: bool, condition: str, nb_samples: int)[source]
Bases:
SmartnoiseSynthCostModel
Model input for a smarnoise-synth query
- condition: str
- model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}
A dictionary of computed field names and their corresponding ComputedFieldInfo objects.
- model_config: ClassVar[ConfigDict] = {}
Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].
- model_fields: ClassVar[dict[str, FieldInfo]] = {'condition': FieldInfo(annotation=str, required=True), 'constraints': FieldInfo(annotation=str, required=True), 'dataset_name': FieldInfo(annotation=str, required=True), 'delta': FieldInfo(annotation=Union[float, NoneType], required=False, default=None), 'epsilon': FieldInfo(annotation=float, required=True, metadata=[Gt(gt=0), Le(le=5.0)]), 'nb_samples': FieldInfo(annotation=int, required=True), 'nullable': FieldInfo(annotation=bool, required=True), 'return_model': FieldInfo(annotation=bool, required=True), 'select_cols': FieldInfo(annotation=List, required=True), 'synth_name': FieldInfo(annotation=Union[SSynthMarginalSynthesizer, SSynthGanSynthesizer], required=True), 'synth_params': FieldInfo(annotation=dict, required=True)}
Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].
This replaces Model.__fields__ from Pydantic V1.
- nb_samples: int
- return_model: bool