diff --git a/.github/workflows/python-package.yml b/.github/workflows/python-package.yml index 885e653..6f03a60 100644 --- a/.github/workflows/python-package.yml +++ b/.github/workflows/python-package.yml @@ -43,7 +43,7 @@ jobs: pylint metasyncontrib/disclosure - name: Check docstrings with pydocstyle run: | - pydocstyle metasyncontrib/disclosure --convention=numpy --add-select=D417 --add-ignore="D102,D105" + pydocstyle metasyncontrib/disclosure --convention=numpy --add-select=D417 --add-ignore="D102,D105,D406" - name: Check types with MyPy run: | mypy metasyncontrib/disclosure diff --git a/examples/tutorial.ipynb b/examples/tutorial.ipynb index 0c66bc3..ed270ee 100644 --- a/examples/tutorial.ipynb +++ b/examples/tutorial.ipynb @@ -13,23 +13,26 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 12, "id": "2442cb34", "metadata": {}, "outputs": [], "source": [ - "# import required packages\n", "from collections import defaultdict\n", - "import datetime as dt\n", "\n", "import numpy as np\n", "import polars as pl\n", "from matplotlib import pyplot as plt\n", - "\n", "from metasyn import MetaFrame, demo_file\n", - "from metasyncontrib.disclosure import DisclosurePrivacy\n", "from metasyn.provider import DistributionProviderList\n", - "#from utils import get_demonstration_fp" + "from metasyn.distribution import (\n", + " DiscreteUniformDistribution,\n", + " FakerDistribution,\n", + " RegexDistribution,\n", + " MultinoulliDistribution,\n", + ")\n", + "\n", + "from metasyncontrib.disclosure import DisclosurePrivacy" ] }, { @@ -45,19 +48,56 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 2, "id": "3c2a44b7", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "shape: (5, 13)
PassengerIdNameSexAgeParchTicketFareCabinEmbarkedBirthdayBoard timeMarried sinceall_NA
i64strcati64i64strf64strcatdatetimedatetime[μs]str
1"Braund, Mr. Ow…"male"220"A/5 21171"7.25null"S"1937-10-2815:53:042022-08-05 04:43:34null
2"Cumings, Mrs. …"female"380"PC 17599"71.2833"C85""C"null12:26:002022-08-07 01:56:33null
3"Heikkinen, Mis…"female"260"STON/O2. 31012…7.925null"S"1931-09-2416:08:252022-08-04 20:27:37null
4"Futrelle, Mrs.…"female"350"113803"53.1"C123""S"1936-11-30null2022-08-07 07:05:55null
5"Allen, Mr. Wil…"male"350"373450"8.05null"S"1918-11-0710:59:082022-08-02 15:13:34null
" + ], + "text/plain": [ + "shape: (5, 13)\n", + "┌─────────────┬───────────────┬────────┬─────┬───┬────────────┬────────────┬──────────────┬────────┐\n", + "│ PassengerId ┆ Name ┆ Sex ┆ Age ┆ … ┆ Birthday ┆ Board time ┆ Married ┆ all_NA │\n", + "│ --- ┆ --- ┆ --- ┆ --- ┆ ┆ --- ┆ --- ┆ since ┆ --- │\n", + "│ i64 ┆ str ┆ cat ┆ i64 ┆ ┆ date ┆ time ┆ --- ┆ str │\n", + "│ ┆ ┆ ┆ ┆ ┆ ┆ ┆ datetime[μs] ┆ │\n", + "╞═════════════╪═══════════════╪════════╪═════╪═══╪════════════╪════════════╪══════════════╪════════╡\n", + "│ 1 ┆ Braund, Mr. ┆ male ┆ 22 ┆ … ┆ 1937-10-28 ┆ 15:53:04 ┆ 2022-08-05 ┆ null │\n", + "│ ┆ Owen Harris ┆ ┆ ┆ ┆ ┆ ┆ 04:43:34 ┆ │\n", + "│ 2 ┆ Cumings, Mrs. ┆ female ┆ 38 ┆ … ┆ null ┆ 12:26:00 ┆ 2022-08-07 ┆ null │\n", + "│ ┆ John Bradley ┆ ┆ ┆ ┆ ┆ ┆ 01:56:33 ┆ │\n", + "│ ┆ (Flor… ┆ ┆ ┆ ┆ ┆ ┆ ┆ │\n", + "│ 3 ┆ Heikkinen, ┆ female ┆ 26 ┆ … ┆ 1931-09-24 ┆ 16:08:25 ┆ 2022-08-04 ┆ null │\n", + "│ ┆ Miss. Laina ┆ ┆ ┆ ┆ ┆ ┆ 20:27:37 ┆ │\n", + "│ 4 ┆ Futrelle, ┆ female ┆ 35 ┆ … ┆ 1936-11-30 ┆ null ┆ 2022-08-07 ┆ null │\n", + "│ ┆ Mrs. Jacques ┆ ┆ ┆ ┆ ┆ ┆ 07:05:55 ┆ │\n", + "│ ┆ Heath (Li… ┆ ┆ ┆ ┆ ┆ ┆ ┆ │\n", + "│ 5 ┆ Allen, Mr. ┆ male ┆ 35 ┆ … ┆ 1918-11-07 ┆ 10:59:08 ┆ 2022-08-02 ┆ null │\n", + "│ ┆ William Henry ┆ ┆ ┆ ┆ ┆ ┆ 15:13:34 ┆ │\n", + "└─────────────┴───────────────┴────────┴─────┴───┴────────────┴────────────┴──────────────┴────────┘" + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ - "demonstration_fp =demo_file()\n", + "titanic_path = demo_file()\n", "df = pl.read_csv(\n", - " source=demonstration_fp, \n", + " source=titanic_path,\n", " try_parse_dates=True,\n", - " dtypes={\n", - " \"Sex\": pl.Categorical,\n", - " \"Embarked\": pl.Categorical\n", - " }\n", + " dtypes={\"Sex\": pl.Categorical, \"Embarked\": pl.Categorical},\n", ")\n", "df.head()" ] @@ -75,27 +115,91 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 7, "id": "b2f5eadd", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 13/13 [00:01<00:00, 12.23it/s]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Lower bound distribution: 2022-07-15 12:21:15\n", + "Lowest value in dataframe: 2022-07-15 12:21:15\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\n" + ] + }, + { + "data": { + "text/html": [ + "
\n", + "shape: (5, 13)
PassengerIdNameSexAgeParchTicketFareCabinEmbarkedBirthdayBoard timeMarried sinceall_NA
i64strcati64i64strf64f32catdatetimedatetime[μs]f32
1"Brittany Brown…"male"250"36347"51.982691null"S"1907-12-0217:07:572022-07-18 17:57:00null
2"Steven Wright""male"250"73559"35.181497null"C"1933-12-1211:25:192022-08-14 11:51:18null
3"Michael Yang""male"200"73510"77.549664null"S"1915-04-2713:42:482022-07-28 21:00:47null
4"Andrew Stout""female"null0"78506"23.700753null"S"null16:17:262022-08-10 00:55:50null
5"Misty Landry""female"null0"9510"15.404263null"S"1932-12-0712:42:442022-07-19 05:43:19null
" + ], + "text/plain": [ + "shape: (5, 13)\n", + "┌─────────────┬──────────────┬────────┬──────┬───┬────────────┬────────────┬──────────────┬────────┐\n", + "│ PassengerId ┆ Name ┆ Sex ┆ Age ┆ … ┆ Birthday ┆ Board time ┆ Married ┆ all_NA │\n", + "│ --- ┆ --- ┆ --- ┆ --- ┆ ┆ --- ┆ --- ┆ since ┆ --- │\n", + "│ i64 ┆ str ┆ cat ┆ i64 ┆ ┆ date ┆ time ┆ --- ┆ f32 │\n", + "│ ┆ ┆ ┆ ┆ ┆ ┆ ┆ datetime[μs] ┆ │\n", + "╞═════════════╪══════════════╪════════╪══════╪═══╪════════════╪════════════╪══════════════╪════════╡\n", + "│ 1 ┆ Brittany ┆ male ┆ 25 ┆ … ┆ 1907-12-02 ┆ 17:07:57 ┆ 2022-07-18 ┆ null │\n", + "│ ┆ Browning ┆ ┆ ┆ ┆ ┆ ┆ 17:57:00 ┆ │\n", + "│ 2 ┆ Steven ┆ male ┆ 25 ┆ … ┆ 1933-12-12 ┆ 11:25:19 ┆ 2022-08-14 ┆ null │\n", + "│ ┆ Wright ┆ ┆ ┆ ┆ ┆ ┆ 11:51:18 ┆ │\n", + "│ 3 ┆ Michael Yang ┆ male ┆ 20 ┆ … ┆ 1915-04-27 ┆ 13:42:48 ┆ 2022-07-28 ┆ null │\n", + "│ ┆ ┆ ┆ ┆ ┆ ┆ ┆ 21:00:47 ┆ │\n", + "│ 4 ┆ Andrew Stout ┆ female ┆ null ┆ … ┆ null ┆ 16:17:26 ┆ 2022-08-10 ┆ null │\n", + "│ ┆ ┆ ┆ ┆ ┆ ┆ ┆ 00:55:50 ┆ │\n", + "│ 5 ┆ Misty Landry ┆ female ┆ null ┆ … ┆ 1932-12-07 ┆ 12:42:44 ┆ 2022-07-19 ┆ null │\n", + "│ ┆ ┆ ┆ ┆ ┆ ┆ ┆ 05:43:19 ┆ │\n", + "└─────────────┴──────────────┴────────┴──────┴───┴────────────┴────────────┴──────────────┴────────┘" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ - "from metasyn.distribution import RegexDistribution, FakerDistribution\n", - "from metasyn.distribution import DiscreteUniformDistribution\n", + "specs = [\n", + " # we set passengerId to unique\n", + " {\"name\": \"PassengerId\", \"distribution\": {\"unique\": True}},\n", + " # We create new fake names for the name column\n", + " {\"name\": \"Name\", \"distribution\": FakerDistribution(\"name\")},\n", + " # Fit an exponential distribution based on the data for fare\n", + " {\"name\": \"Fare\", \"distribution\": {\"implements\": \"core.exponential\"}},\n", + " # For age we enforce a specific uniform distribution\n", + " {\"name\": \"Age\", \"distribution\": DiscreteUniformDistribution(20, 40)},\n", + " # We know cabin has a specific regular expression\n", + " {\"name\": \"Cabin\", \"distribution\": RegexDistribution(r\"[ABCDEF][0-9]{2,3}\")},\n", + "]\n", "\n", - "cabin_distribution = RegexDistribution(r\"[ABCDEF][0-9]{2,3}\")\n", - "var_spec = {\n", - " \"PassengerId\": {\"unique\": True}, \n", - " \"Name\": {\"distribution\": FakerDistribution(\"name\")},\n", - " \"Fare\": {\"distribution\": \"exponential\"}, # Fit an exponential distribution based on the data\n", - " \"Age\": {\"distribution\": DiscreteUniformDistribution(20, 40)},\n", - " \"Cabin\": {\"distribution\": cabin_distribution}\n", - "}\n", + "mf = MetaFrame.fit_dataframe(df, var_specs=specs)\n", "\n", - "meta_frame = MetaFrame.fit_dataframe(df, spec=var_spec)\n", - "print(f\"Lower bound distribution: {meta_frame['Married since'].distribution.start}\\n\"\n", - " f\"Lowest value in dataframe: {df['Married since'].min()}\")\n", - "meta_frame.synthesize(5)" + "print(\n", + " f\"Lower bound distribution: {mf['Married since'].distribution.lower}\\n\"\n", + " f\"Lowest value in dataframe: {df['Married since'].min()}\"\n", + ")\n", + "mf.synthesize(5)" ] }, { @@ -120,19 +224,79 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 9, "id": "b8b96c16", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 13/13 [00:02<00:00, 5.16it/s]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Lower bound distribution: 2022-07-15 17:12:24\n", + "Lowest value in dataframe: 2022-07-15 12:21:15\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\n" + ] + }, + { + "data": { + "text/html": [ + "
\n", + "shape: (5, 13)
PassengerIdNameSexAgeParchTicketFareCabinEmbarkedBirthdayBoard timeMarried sinceall_NA
i64strcati64i64f32f64f32catdatetimedatetime[μs]f32
3"Store. Rise.""male"300null135.292425null"Q"1921-01-3013:25:14nullnull
3"Adult.""female"300null37.80435null"S"1928-09-0112:18:42nullnull
3"Doctor.""female"null0null8.235304null"S"null18:26:392022-08-14 15:50:52null
3"View. The.""male"190null10.90519null"C"null13:42:532022-07-31 18:46:04null
3"Some. I. Plant…"male"null1null0.539828null"S"null16:37:16nullnull
" + ], + "text/plain": [ + "shape: (5, 13)\n", + "┌─────────────┬──────────────┬────────┬──────┬───┬────────────┬────────────┬──────────────┬────────┐\n", + "│ PassengerId ┆ Name ┆ Sex ┆ Age ┆ … ┆ Birthday ┆ Board time ┆ Married ┆ all_NA │\n", + "│ --- ┆ --- ┆ --- ┆ --- ┆ ┆ --- ┆ --- ┆ since ┆ --- │\n", + "│ i64 ┆ str ┆ cat ┆ i64 ┆ ┆ date ┆ time ┆ --- ┆ f32 │\n", + "│ ┆ ┆ ┆ ┆ ┆ ┆ ┆ datetime[μs] ┆ │\n", + "╞═════════════╪══════════════╪════════╪══════╪═══╪════════════╪════════════╪══════════════╪════════╡\n", + "│ 3 ┆ Store. Rise. ┆ male ┆ 30 ┆ … ┆ 1921-01-30 ┆ 13:25:14 ┆ null ┆ null │\n", + "│ 3 ┆ Adult. ┆ female ┆ 30 ┆ … ┆ 1928-09-01 ┆ 12:18:42 ┆ null ┆ null │\n", + "│ 3 ┆ Doctor. ┆ female ┆ null ┆ … ┆ null ┆ 18:26:39 ┆ 2022-08-14 ┆ null │\n", + "│ ┆ ┆ ┆ ┆ ┆ ┆ ┆ 15:50:52 ┆ │\n", + "│ 3 ┆ View. The. ┆ male ┆ 19 ┆ … ┆ null ┆ 13:42:53 ┆ 2022-07-31 ┆ null │\n", + "│ ┆ ┆ ┆ ┆ ┆ ┆ ┆ 18:46:04 ┆ │\n", + "│ 3 ┆ Some. I. ┆ male ┆ null ┆ … ┆ null ┆ 16:37:16 ┆ null ┆ null │\n", + "│ ┆ Plant. ┆ ┆ ┆ ┆ ┆ ┆ ┆ │\n", + "└─────────────┴──────────────┴────────┴──────┴───┴────────────┴────────────┴──────────────┴────────┘" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "meta_frame = MetaFrame.fit_dataframe(\n", - " df=df, \n", - " spec=var_spec,\n", + " df=df,\n", + " var_specs=specs,\n", " dist_providers=\"metasyn-disclosure\", # Use the metasyn-disclosure plugin\n", - " privacy=DisclosurePrivacy() # Use disclosure control\n", - ") \n", - "print(f\"Lower bound distribution: {meta_frame['Married since'].distribution.start}\\n\"\n", - " f\"Lowest value in dataframe: {df['Married since'].min()}\")\n", + " privacy=DisclosurePrivacy(), # Use disclosure control\n", + ")\n", + "print(\n", + " f\"Lower bound distribution: {meta_frame['Married since'].distribution.lower}\\n\"\n", + " f\"Lowest value in dataframe: {df['Married since'].min()}\"\n", + ")\n", "meta_frame.synthesize(5)" ] }, @@ -167,17 +331,17 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 10, "id": "6630b9a3", "metadata": {}, "outputs": [], "source": [ - "from metasyn.distribution import MultinoulliDistribution\n", - "\n", "def plot_outliers(dist_type, series_size=50):\n", " dist_providers = DistributionProviderList([\"builtin\", \"metasyn-disclosure\"])\n", - " disc_distributions = dist_providers.get_distributions(var_type=dist_type, privacy=DisclosurePrivacy())\n", - " \n", + " disc_distributions = dist_providers.get_distributions(\n", + " var_type=dist_type, privacy=DisclosurePrivacy()\n", + " )\n", + "\n", " for disc_class in disc_distributions:\n", " if issubclass(disc_class, MultinoulliDistribution):\n", " continue\n", @@ -190,6 +354,7 @@ "\n", " base_param = defaultdict(lambda: [])\n", " disc_param = defaultdict(lambda: [])\n", + "\n", " def _add(parameters, param, new_val):\n", " for key, val in param.items():\n", " parameters[key].append(val)\n", @@ -205,13 +370,21 @@ " for param in base_param:\n", " if param == \"new_val\":\n", " continue\n", - " plt.plot(base_param[\"new_val\"], np.array(base_param[param])-clean_base_param[param], label=\"base\")\n", - " plt.plot(disc_param[\"new_val\"], np.array(disc_param[param]) - clean_disc_param[param], label=\"disclosure\")\n", + " plt.plot(\n", + " base_param[\"new_val\"],\n", + " np.array(base_param[param]) - clean_base_param[param],\n", + " label=\"base\",\n", + " )\n", + " plt.plot(\n", + " disc_param[\"new_val\"],\n", + " np.array(disc_param[param]) - clean_disc_param[param],\n", + " label=\"disclosure\",\n", + " )\n", " plt.title(f\"{disc_class.__name__}: {param}\")\n", " plt.ylabel(\"Difference between dist with and without outlier\")\n", " plt.xlabel(\"Value of the outlier\")\n", " plt.legend()\n", - " plt.show()\n" + " plt.show()" ] }, { @@ -225,10 +398,131 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 13, "id": "fd6903c2", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "plot_outliers(\"continuous\")" ] @@ -253,10 +547,111 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 14, "id": "fe8c4afc", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "plot_outliers(\"discrete\")" ] @@ -287,7 +682,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.11.5" + "version": "3.11.3" }, "vscode": { "interpreter": { diff --git a/metasyncontrib/disclosure/base.py b/metasyncontrib/disclosure/base.py index 7027ae0..85b69d3 100644 --- a/metasyncontrib/disclosure/base.py +++ b/metasyncontrib/disclosure/base.py @@ -9,8 +9,10 @@ def metadist_disclosure(): cls: Class with the appropriate class variables. """ + def _wrap(cls): cls.provenance = "metasyn-disclosure" cls.privacy = "disclosure" return cls + return _wrap diff --git a/metasyncontrib/disclosure/categorical.py b/metasyncontrib/disclosure/categorical.py index cec05a3..ec41ecb 100644 --- a/metasyncontrib/disclosure/categorical.py +++ b/metasyncontrib/disclosure/categorical.py @@ -1,8 +1,11 @@ """Disclosure classes for categorical variables.""" -import polars as pl +from __future__ import annotations +import polars as pl from metasyn.distribution.categorical import MultinoulliDistribution +from metasyn.var import MetaVar + from metasyncontrib.disclosure.base import metadist_disclosure @@ -10,16 +13,18 @@ class DisclosureMultinoulli(MultinoulliDistribution): """Disclosure variant for multinoulli distribution. - It checks that all labels appear at least x times, and that + It checks that all labels appear at least n_avg times, and that there is no label with >90% of the counts. """ @classmethod def _fit(cls, values: pl.Series, n_avg: int = 11): - dist = super(DisclosureMultinoulli, cls)._fit(values) - labels = dist.labels[dist.probs >= n_avg/len(values)] - probs = dist.probs[dist.probs >= n_avg/len(values)] + dist = super()._fit(values) + labels = dist.labels[dist.probs >= n_avg / len(values)] + probs = dist.probs[dist.probs >= n_avg / len(values)] if len(probs) == 0 or probs.max() >= 0.9: + if MetaVar.get_var_type(values) == "discrete": + return cls([1, 2, 3], [0.1, 0.2, 0.7]) # type: ignore return cls.default_distribution() probs /= probs.sum() return cls(labels, probs) diff --git a/metasyncontrib/disclosure/constant.py b/metasyncontrib/disclosure/constant.py index c4b69b4..40c3a81 100644 --- a/metasyncontrib/disclosure/constant.py +++ b/metasyncontrib/disclosure/constant.py @@ -1,63 +1,66 @@ """Module for disclosure controlled constant distributions.""" +from __future__ import annotations + import polars as pl +from metasyn.distribution.base import BaseDistribution from metasyn.distribution.constant import ( ConstantDistribution, + DateConstantDistribution, + DateTimeConstantDistribution, DiscreteConstantDistribution, StringConstantDistribution, - DateTimeConstantDistribution, TimeConstantDistribution, - DateConstantDistribution, ) + from metasyncontrib.disclosure.base import metadist_disclosure -def disclosure_constant(cls): - """Override _fit method for constant distributions using this decorator.""" - def _fit(values: pl.Series, n_avg=11): - # if unique, just get that value if it occurs at least n_avg times - if values.n_unique() == 1 & values.len() >= n_avg: - return cls(values.unique()[0]) +class DisclosureConstantMixin(BaseDistribution): + """Mixin class to overload fit method for constant distributions.""" - # otherwise get most common value - val_counts = values.value_counts(sort=True) - value = val_counts[0,0] - count = val_counts[0,1] + @classmethod + def fit(cls, series, *args, n_avg: int = 11, **kwargs) -> BaseDistribution: + """Fit constant distributions with disclosure control rules in place.""" + pl_series: pl.Series = cls._to_series(series) - if count >= n_avg: - return cls(value) + # if unique, just get that value if it occurs at least n_avg times + if pl_series.n_unique() == 1 and pl_series.len() >= n_avg: + return cls._fit(pl_series, *args, **kwargs) - return cls.default_distribution() + if pl_series.n_unique() > 1: + # if not unique, ensure most common value occurs at least n_avg times + _value, count = pl_series.value_counts(sort=True).row(0) + if count >= n_avg: + return cls._fit(pl_series, *args, **kwargs) - setattr(cls, "_fit", _fit) - return cls + return cls.default_distribution() @metadist_disclosure() -@disclosure_constant -class DisclosureConstant(ConstantDistribution): +class DisclosureConstant(DisclosureConstantMixin, ConstantDistribution): """Disclosure controlled ConstantDistribution.""" + @metadist_disclosure() -@disclosure_constant -class DisclosureDiscreteConstant(DiscreteConstantDistribution): +class DisclosureDiscreteConstant(DisclosureConstantMixin, DiscreteConstantDistribution): """Disclosure controlled DiscreteConstantDistribution.""" + @metadist_disclosure() -@disclosure_constant -class DisclosureStringConstant(StringConstantDistribution): +class DisclosureStringConstant(DisclosureConstantMixin, StringConstantDistribution): """Disclosure controlled StringConstantDistribution.""" + @metadist_disclosure() -@disclosure_constant -class DisclosureDateTimeConstant(DateTimeConstantDistribution): +class DisclosureDateTimeConstant(DisclosureConstantMixin, DateTimeConstantDistribution): """Disclosure controlled DateTimeConstantDistribution.""" + @metadist_disclosure() -@disclosure_constant -class DisclosureTimeConstant(TimeConstantDistribution): +class DisclosureTimeConstant(DisclosureConstantMixin, TimeConstantDistribution): """Disclosure controlled TimeConstantDistribution.""" + @metadist_disclosure() -@disclosure_constant -class DisclosureDateConstant(DateConstantDistribution): +class DisclosureDateConstant(DisclosureConstantMixin, DateConstantDistribution): """Disclosure controlled DateConstantDistribution.""" diff --git a/metasyncontrib/disclosure/continuous.py b/metasyncontrib/disclosure/continuous.py index 84c89d2..4ee1902 100644 --- a/metasyncontrib/disclosure/continuous.py +++ b/metasyncontrib/disclosure/continuous.py @@ -1,34 +1,37 @@ """Disclosure control implementations for continuous distributions.""" -from metasyn.distribution.continuous import UniformDistribution -from metasyn.distribution.continuous import NormalDistribution, LogNormalDistribution -from metasyn.distribution.continuous import ExponentialDistribution -from metasyn.distribution.continuous import TruncatedNormalDistribution +from metasyn.distribution.continuous import ( + ExponentialDistribution, + LogNormalDistribution, + NormalDistribution, + TruncatedNormalDistribution, + UniformDistribution, +) -from metasyncontrib.disclosure.numerical import DisclosureNumerical from metasyncontrib.disclosure.base import metadist_disclosure +from metasyncontrib.disclosure.numerical import DisclosureNumericalMixin @metadist_disclosure() -class DisclosureUniform(DisclosureNumerical, UniformDistribution): +class DisclosureUniform(DisclosureNumericalMixin, UniformDistribution): """Uniform distribution implementation.""" @metadist_disclosure() -class DisclosureTruncatedNormal(DisclosureNumerical, TruncatedNormalDistribution): - """Truncated normal distribution implementation.""" +class DisclosureNormal(DisclosureNumericalMixin, NormalDistribution): + """Disclosure normal distribution.""" @metadist_disclosure() -class DisclosureNormal(DisclosureNumerical, NormalDistribution): - """Disclosure normal distribution.""" +class DisclosureLogNormal(DisclosureNumericalMixin, LogNormalDistribution): + """Disclosure log-normal distribution.""" @metadist_disclosure() -class DisclosureLogNormal(DisclosureNumerical, LogNormalDistribution): - """Disclosure log-normal distribution.""" +class DisclosureTruncatedNormal(DisclosureNumericalMixin, TruncatedNormalDistribution): + """Truncated normal distribution implementation.""" @metadist_disclosure() -class DisclosureExponential(DisclosureNumerical, ExponentialDistribution): +class DisclosureExponential(DisclosureNumericalMixin, ExponentialDistribution): """Disclosure exponential distribution.""" diff --git a/metasyncontrib/disclosure/datetime.py b/metasyncontrib/disclosure/datetime.py index 32f389e..651d2ff 100644 --- a/metasyncontrib/disclosure/datetime.py +++ b/metasyncontrib/disclosure/datetime.py @@ -1,16 +1,20 @@ """Disclosure classes for date/time/datetime distributions.""" from __future__ import annotations + import datetime as dt import polars as pl +from metasyn.distribution.datetime import ( + DateTimeUniformDistribution, + DateUniformDistribution, + TimeUniformDistribution, +) + +from metasyncontrib.disclosure.base import metadist_disclosure -from metasyn.distribution.datetime import DateTimeUniformDistribution -from metasyn.distribution.datetime import TimeUniformDistribution -from metasyn.distribution.datetime import DateUniformDistribution # from metasyncontrib.disclosure.base import BaseDisclosureDistribution from metasyncontrib.disclosure.utils import micro_aggregate -from metasyncontrib.disclosure.base import metadist_disclosure @metadist_disclosure() diff --git a/metasyncontrib/disclosure/discrete.py b/metasyncontrib/disclosure/discrete.py index 10d6352..20d7a97 100644 --- a/metasyncontrib/disclosure/discrete.py +++ b/metasyncontrib/disclosure/discrete.py @@ -3,21 +3,41 @@ from __future__ import annotations import polars as pl +from metasyn.distribution.discrete import ( + DiscreteNormalDistribution, + DiscreteTruncatedNormalDistribution, + DiscreteUniformDistribution, + PoissonDistribution, + UniqueKeyDistribution, +) -from metasyn.distribution.discrete import DiscreteUniformDistribution -from metasyn.distribution.discrete import PoissonDistribution -from metasyn.distribution.discrete import UniqueKeyDistribution - -from metasyncontrib.disclosure.numerical import DisclosureNumerical -from metasyncontrib.disclosure.utils import micro_aggregate from metasyncontrib.disclosure.base import metadist_disclosure +from metasyncontrib.disclosure.numerical import DisclosureNumericalMixin +from metasyncontrib.disclosure.utils import micro_aggregate + + +@metadist_disclosure() +class DisclosureDiscreteUniform(DisclosureNumericalMixin, DiscreteUniformDistribution): + """Implementation for discrete uniform distribution.""" @metadist_disclosure() -class DisclosureDiscreteUniform(DisclosureNumerical, DiscreteUniformDistribution): +class DisclosureDiscreteNormal(DisclosureNumericalMixin, DiscreteNormalDistribution): """Implementation for discrete uniform distribution.""" +@metadist_disclosure() +class DisclosureDiscreteTruncatedNormal( + DisclosureNumericalMixin, DiscreteTruncatedNormalDistribution +): + """Implementation for discrete uniform distribution.""" + + +@metadist_disclosure() +class DisclosurePoisson(DisclosureNumericalMixin, PoissonDistribution): + """Disclosure implementation for Poisson distribution.""" + + @metadist_disclosure() class DisclosureUniqueKey(UniqueKeyDistribution): """Implementation for unique key distribution.""" @@ -29,8 +49,3 @@ def _fit(cls, values: pl.Series, n_avg: int = 11): return cls(0, True) sub_values = micro_aggregate(values, n_avg) return super()._fit(sub_values) - - -@metadist_disclosure() -class DisclosurePoisson(DisclosureNumerical, PoissonDistribution): - """Disclosure implementation for Poisson distribution.""" diff --git a/metasyncontrib/disclosure/faker.py b/metasyncontrib/disclosure/faker.py new file mode 100644 index 0000000..f6ca192 --- /dev/null +++ b/metasyncontrib/disclosure/faker.py @@ -0,0 +1,36 @@ +"""Module for disclosure control for string distributions.""" + +from metasyn.distribution.faker import ( + FakerDistribution, + FreeTextDistribution, + UniqueFakerDistribution, +) + +from metasyncontrib.disclosure.base import metadist_disclosure + + +@metadist_disclosure() +class DisclosureFaker(FakerDistribution): + """Faker distribution for disclosure control.""" + + @classmethod + def _fit(cls, values, faker_type: str = "city", locale: str = "en_US", n_avg: int = 11): # pylint: disable=unused-argument + return super()._fit(values, faker_type=faker_type, locale=locale) + + +@metadist_disclosure() +class DisclosureUniqueFaker(UniqueFakerDistribution): + """Faker distribution for disclosure control that produces unique values.""" + + @classmethod + def _fit(cls, values, faker_type: str = "city", locale: str = "en_US", n_avg: int = 11): # pylint: disable=unused-argument + return super()._fit(values, faker_type=faker_type, locale=locale) + + +@metadist_disclosure() +class DisclosureFreetext(FreeTextDistribution): + """Disclosure implementation of freetext distribution.""" + + @classmethod + def _fit(cls, values, max_values: int = 50, n_avg: int = 11): # pylint: disable=unused-argument + return super()._fit(values, max_values=max_values) diff --git a/metasyncontrib/disclosure/na.py b/metasyncontrib/disclosure/na.py new file mode 100644 index 0000000..0fac418 --- /dev/null +++ b/metasyncontrib/disclosure/na.py @@ -0,0 +1,11 @@ +"""Module for disclosure-controlled NA distribution.""" +from __future__ import annotations + +from metasyn.distribution.na import NADistribution + +from metasyncontrib.disclosure.base import metadist_disclosure + + +@metadist_disclosure() +class DisclosureNA(NADistribution): + """Disclosure version of NA distribution.""" diff --git a/metasyncontrib/disclosure/numerical.py b/metasyncontrib/disclosure/numerical.py index b3b3637..c90f3d8 100644 --- a/metasyncontrib/disclosure/numerical.py +++ b/metasyncontrib/disclosure/numerical.py @@ -6,11 +6,12 @@ from metasyncontrib.disclosure.utils import micro_aggregate -class DisclosureNumerical(BaseDistribution): - """Class for numerical distributions of the disclosure kind.""" +class DisclosureNumericalMixin(BaseDistribution): + """Mixin class to create numerical distributions of the disclosure kind.""" @classmethod def fit(cls, series, *args, n_avg: int = 11, **kwargs) -> BaseDistribution: + """Fit numeric distributions with disclosure control rules in place.""" pl_series = cls._to_series(series) sub_series = micro_aggregate(pl_series, n_avg) return cls._fit(sub_series, *args, **kwargs) diff --git a/metasyncontrib/disclosure/privacy.py b/metasyncontrib/disclosure/privacy.py index d9ddae4..fd6ee98 100644 --- a/metasyncontrib/disclosure/privacy.py +++ b/metasyncontrib/disclosure/privacy.py @@ -8,7 +8,7 @@ class DisclosurePrivacy(BasePrivacy): """Disclosure control privacy class that uses micro-aggregation. - Arguments + Arguments: --------- n_avg: Number of elements to aggregate into one bin. Higher values @@ -18,10 +18,9 @@ class DisclosurePrivacy(BasePrivacy): name = "disclosure" def __init__(self, n_avg: int = 11): + """Initialize the disclosure privacy object.""" self.n_avg = n_avg def to_dict(self) -> dict: - return { - "type": self.name, - "parameters": {"n_avg": self.n_avg} - } + """Create a dictionary that gives the privacy type, and parameters.""" + return {"name": self.name, "parameters": {"n_avg": self.n_avg}} diff --git a/metasyncontrib/disclosure/provider.py b/metasyncontrib/disclosure/provider.py index 64ad160..f7ae7b1 100644 --- a/metasyncontrib/disclosure/provider.py +++ b/metasyncontrib/disclosure/provider.py @@ -1,33 +1,39 @@ -"""Module contains distribution tree for disclosure control.""" +"""Module contains distribution provider for disclosure control.""" from __future__ import annotations + from metasyn.provider import BaseDistributionProvider +from metasyncontrib.disclosure.categorical import DisclosureMultinoulli +from metasyncontrib.disclosure.constant import ( + DisclosureConstant, + DisclosureDateConstant, + DisclosureDateTimeConstant, + DisclosureDiscreteConstant, + DisclosureStringConstant, + DisclosureTimeConstant, +) from metasyncontrib.disclosure.continuous import ( - DisclosureUniform, + DisclosureExponential, + DisclosureLogNormal, + DisclosureNormal, DisclosureTruncatedNormal, + DisclosureUniform, ) -from metasyncontrib.disclosure.continuous import DisclosureNormal -from metasyncontrib.disclosure.continuous import DisclosureLogNormal -from metasyncontrib.disclosure.continuous import DisclosureExponential +from metasyncontrib.disclosure.datetime import DisclosureDate, DisclosureDateTime, DisclosureTime from metasyncontrib.disclosure.discrete import ( + DisclosureDiscreteNormal, + DisclosureDiscreteTruncatedNormal, DisclosureDiscreteUniform, + DisclosurePoisson, DisclosureUniqueKey, ) -from metasyncontrib.disclosure.discrete import DisclosurePoisson -from metasyncontrib.disclosure.string import DisclosureFaker, DisclosureUniqueFaker -from metasyncontrib.disclosure.categorical import DisclosureMultinoulli -from metasyncontrib.disclosure.datetime import DisclosureDate -from metasyncontrib.disclosure.datetime import DisclosureDateTime -from metasyncontrib.disclosure.datetime import DisclosureTime -from metasyncontrib.disclosure.constant import ( - DisclosureConstant, - DisclosureDiscreteConstant, - DisclosureStringConstant, - DisclosureDateTimeConstant, - DisclosureTimeConstant, - DisclosureDateConstant, +from metasyncontrib.disclosure.faker import ( + DisclosureFaker, + DisclosureFreetext, + DisclosureUniqueFaker, ) +from metasyncontrib.disclosure.na import DisclosureNA class DisclosureProvider(BaseDistributionProvider): @@ -40,24 +46,28 @@ class DisclosureProvider(BaseDistributionProvider): name = "metasyn-disclosure" version = "1.0" distributions = [ - DisclosureUniform, - DisclosureTruncatedNormal, - DisclosureNormal, - DisclosureLogNormal, - DisclosureExponential, - DisclosureDiscreteUniform, - DisclosureUniqueKey, - DisclosurePoisson, DisclosureMultinoulli, - DisclosureFaker, - DisclosureUniqueFaker, - DisclosureDate, - DisclosureTime, - DisclosureDateTime, DisclosureConstant, + DisclosureDateConstant, + DisclosureDateTimeConstant, DisclosureDiscreteConstant, DisclosureStringConstant, - DisclosureDateTimeConstant, DisclosureTimeConstant, - DisclosureDateConstant, + DisclosureExponential, + DisclosureLogNormal, + DisclosureNormal, + DisclosureTruncatedNormal, + DisclosureUniform, + DisclosureDate, + DisclosureDateTime, + DisclosureTime, + DisclosureDiscreteNormal, + DisclosureDiscreteTruncatedNormal, + DisclosureDiscreteUniform, + DisclosurePoisson, + DisclosureUniqueKey, + DisclosureFaker, + DisclosureUniqueFaker, + DisclosureFreetext, + DisclosureNA, ] diff --git a/metasyncontrib/disclosure/string.py b/metasyncontrib/disclosure/string.py deleted file mode 100644 index e8145c5..0000000 --- a/metasyncontrib/disclosure/string.py +++ /dev/null @@ -1,28 +0,0 @@ -"""Module for disclosure control for string distributions.""" - -from metasyn.distribution.faker import FakerDistribution, UniqueFakerDistribution -from metasyncontrib.disclosure.base import metadist_disclosure - - -@metadist_disclosure() -class DisclosureFaker(FakerDistribution): - """Faker distribution for disclosure control.""" - - @classmethod - def _fit(cls, values, - faker_type: str = "city", - locale: str = "en_US", n_avg=11): # pylint: disable=unused-argument - return super(DisclosureFaker, cls)._fit(values, faker_type=faker_type, - locale=locale) - - -@metadist_disclosure() -class DisclosureUniqueFaker(UniqueFakerDistribution): - """Faker distribution for disclosure control that produces unique values.""" - - @classmethod - def _fit(cls, values, - faker_type: str = "city", - locale: str = "en_US", n_avg=11): # pylint: disable=unused-argument - return super(DisclosureUniqueFaker, cls)._fit(values, faker_type=faker_type, - locale=locale) diff --git a/metasyncontrib/disclosure/utils.py b/metasyncontrib/disclosure/utils.py index 02cbd42..86a86ca 100644 --- a/metasyncontrib/disclosure/utils.py +++ b/metasyncontrib/disclosure/utils.py @@ -1,12 +1,12 @@ """Utilities for disclosure control.""" from __future__ import annotations + import datetime as dt from typing import NamedTuple, Optional import numpy as np import polars as pl - from numpy.core._exceptions import UFuncTypeError @@ -20,34 +20,39 @@ def _compute_dominance(block_values, reverse=False): diff_values = max_values - block_values same_vals = np.all(block_values == max_values, axis=1) diff_sum = diff_values.sum(axis=1) - dominance = diff_values[~same_vals].max(axis=1)/diff_sum[~same_vals] + dominance = diff_values[~same_vals].max(axis=1) / diff_sum[~same_vals] return np.max(dominance) -def _create_subsample(values, n_avg: int = 11, # pylint: disable=too-many-locals - pre_remove: int = 0, - post_remove: int = 0) -> tuple[list, float]: +def _create_subsample( # pylint: disable=too-many-locals + values, + n_avg: int = 11, + pre_remove: int = 0, + post_remove: int = 0, +) -> tuple[list, float]: sorted_values = np.sort(values) - sorted_values = sorted_values[pre_remove:len(values)-post_remove] + sorted_values = sorted_values[pre_remove : len(values) - post_remove] n_values = len(sorted_values) - n_blocks = n_values//n_avg + n_blocks = n_values // n_avg if n_blocks <= 1: raise ValueError("Cannot find subsample with current settings.") - min_block_size = n_values//n_blocks - leftover = n_values - n_blocks*min_block_size + min_block_size = n_values // n_blocks + leftover = n_values - n_blocks * min_block_size if leftover == 1: - sorted_values = np.delete(sorted_values, [n_values//2]) + sorted_values = np.delete(sorted_values, [n_values // 2]) if leftover > 1: - base_skip = round(n_values/(leftover+1)) - skip_start = (n_values - base_skip*(leftover-1) + 1) // 2 - delete_values = skip_start + base_skip*np.arange(leftover) + base_skip = round(n_values / (leftover + 1)) + skip_start = (n_values - base_skip * (leftover - 1) + 1) // 2 + delete_values = skip_start + base_skip * np.arange(leftover) sorted_values = np.delete(sorted_values, delete_values) - assert len(sorted_values) == n_blocks*min_block_size + assert len(sorted_values) == n_blocks * min_block_size block_values = sorted_values.reshape(n_blocks, min_block_size) - dominance = max(_compute_dominance(block_values, reverse=False), - _compute_dominance(block_values, reverse=True)) + dominance = max( + _compute_dominance(block_values, reverse=False), + _compute_dominance(block_values, reverse=True), + ) try: sub_values = block_values.mean(axis=1) except UFuncTypeError: @@ -57,23 +62,24 @@ def _create_subsample(values, n_avg: int = 11, # pylint: disable=too-many-local for block in block_values: mean_time = pl.Series(block).dt.cast_time_unit("us").mean() assert mean_time is not None - sec_since_1970 = mean_time/1e6 - sub_values.append(dt.datetime.utcfromtimestamp(0) - + dt.timedelta(seconds=sec_since_1970)) + sec_since_1970 = mean_time / 1e6 + sub_values.append( + dt.datetime.utcfromtimestamp(0) + dt.timedelta(seconds=sec_since_1970) + ) return sub_values, dominance def micro_aggregate(values: pl.Series, min_bin: int = 11) -> pl.Series: """Use micro-aggregation to make the data safe for disclosure purposes. - Arguments + Arguments: --------- values: Values that need to be micro-aggregated. min_bin: Micro-aggregate over at least this many values. - Returns + Returns: ------- new_values: Aggregated values. @@ -93,27 +99,30 @@ class Solution(NamedTuple): # pylint: disable=missing-class-docstring break best_solution: Optional[Solution] = None - max_diff = cur_settings[0]//2 + max_diff = cur_settings[0] // 2 for i_par in range(3): for add_par in range(1, max_diff): - new_settings = [x if j_par != i_par else x+add_par - for j_par, x in enumerate(cur_settings)] + new_settings = [ + x if j_par != i_par else x + add_par for j_par, x in enumerate(cur_settings) + ] try: new_bin, new_dom = _create_subsample(values, *new_settings) except ValueError: continue - grad = (dominance-new_dom) / add_par + grad = (dominance - new_dom) / add_par if best_solution is None or best_solution.grad < grad: best_solution = Solution(new_bin, new_dom, new_settings, grad) if best_solution is None: - raise ValueError("Could not find solution satisfying dominance conditions for column" - f" '{values.name}'.") + raise ValueError( + "Could not find solution satisfying dominance conditions for column" + f" '{values.name}'." + ) dominance = best_solution.dominance cur_settings = best_solution.settings sub_values = best_solution.sub_values # If the values are integer types, round the values to the nearest integer. if values.dtype in [pl.datatypes.Int64, pl.datatypes.Int32, pl.datatypes.Int32]: - return pl.Series((np.array(sub_values)+0.5).astype(np.int64)) + return pl.Series((np.array(sub_values) + 0.5).astype(np.int64)) return pl.Series(sub_values) diff --git a/pyproject.toml b/pyproject.toml index 69c7f1c..2584af1 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -6,6 +6,7 @@ build-backend = "setuptools.build_meta" name = "metasyn-disclosure" authors = [ {name = "Raoul Schram", email = "r.d.schram@uu.nl"}, + {name = "Erik-Jan van Kesteren", email = "e.vankesteren1@uu.nl"}, ] description = "Plugin package for metasyn that applies the disclosure control." readme = "README.md" @@ -30,5 +31,12 @@ packages = ["metasyncontrib"] metasyn-disclosure = "metasyncontrib.disclosure.provider:DisclosureProvider" [project.entry-points."metasyn.privacy"] - disclosure = "metasyncontrib.disclosure.privacy:DisclosurePrivacy" + +[tool.ruff] +line-length = 100 +target-version = "py311" + +[tool.ruff.lint] +select = ["C", "D", "E", "F", "UP", "B", "SIM", "I", "N", "W"] +ignore = ["D203", "D213", "D206", "UP007"] \ No newline at end of file diff --git a/tests/test_constant.py b/tests/test_constant.py index 013a2a1..a4826eb 100644 --- a/tests/test_constant.py +++ b/tests/test_constant.py @@ -1,37 +1,37 @@ -from pytest import mark - from metasyn.distribution.constant import ( ConstantDistribution, + DateConstantDistribution, + DateTimeConstantDistribution, DiscreteConstantDistribution, StringConstantDistribution, - DateTimeConstantDistribution, TimeConstantDistribution, - DateConstantDistribution, ) +from pytest import mark from metasyncontrib.disclosure.constant import ( DisclosureConstant, + DisclosureDateConstant, + DisclosureDateTimeConstant, DisclosureDiscreteConstant, DisclosureStringConstant, - DisclosureDateTimeConstant, DisclosureTimeConstant, - DisclosureDateConstant, ) + @mark.parametrize( "dist_builtin, dist_disclosure, value", [ (ConstantDistribution, DisclosureConstant, 8.0), (DiscreteConstantDistribution, DisclosureDiscreteConstant, 8), (StringConstantDistribution, DisclosureStringConstant, "Secretvalue"), - (DateTimeConstantDistribution, DisclosureDateTimeConstant, "2024-02-23T12:08:38+00:00"), + (DateTimeConstantDistribution, DisclosureDateTimeConstant, "2024-02-23T12:08:38"), (TimeConstantDistribution, DisclosureTimeConstant, "12:08:38"), - (DateConstantDistribution, DisclosureDateConstant, "2024-02-23") - ] + (DateConstantDistribution, DisclosureDateConstant, "2024-02-23"), + ], ) def test_constant(dist_builtin, dist_disclosure, value): dist = dist_builtin(value) data = [dist.draw() for _ in range(21)] - - assert dist_disclosure.fit(data, n_avg = 22)._param_dict().get("value") != value - assert dist_disclosure.fit(data, n_avg = 11)._param_dict().get("value") == value + + assert dist_disclosure.fit(data, n_avg=22)._param_dict().get("value") != value + assert dist_disclosure.fit(data, n_avg=11)._param_dict().get("value") == value diff --git a/tests/test_numerical.py b/tests/test_numerical.py index 371bcf8..ecd5de9 100644 --- a/tests/test_numerical.py +++ b/tests/test_numerical.py @@ -1,29 +1,35 @@ -from pytest import mark import polars as pl +from metasyn.distribution.continuous import ( + ExponentialDistribution, + LogNormalDistribution, + NormalDistribution, + TruncatedNormalDistribution, + UniformDistribution, +) +from metasyn.distribution.discrete import DiscreteUniformDistribution +from pytest import mark -from metasyn.distribution.continuous import UniformDistribution, TruncatedNormalDistribution -from metasyn.distribution.continuous import NormalDistribution, LogNormalDistribution -from metasyn.distribution.continuous import ExponentialDistribution -from metasyncontrib.disclosure.continuous import DisclosureUniform, DisclosureTruncatedNormal -from metasyncontrib.disclosure.continuous import DisclosureNormal, DisclosureLogNormal -from metasyncontrib.disclosure.continuous import DisclosureExponential +from metasyncontrib.disclosure.continuous import ( + DisclosureExponential, + DisclosureLogNormal, + DisclosureNormal, + DisclosureTruncatedNormal, + DisclosureUniform, +) from metasyncontrib.disclosure.discrete import DisclosureDiscreteUniform -from metasyncontrib.disclosure.discrete import DisclosurePoisson - -from metasyn.distribution.discrete import DiscreteUniformDistribution,\ - PoissonDistribution @mark.parametrize( "dist_normal,dist_disclosure", - [(UniformDistribution, DisclosureUniform), - (TruncatedNormalDistribution, DisclosureTruncatedNormal), - (NormalDistribution, DisclosureNormal), - (LogNormalDistribution, DisclosureLogNormal), - (ExponentialDistribution, DisclosureExponential), - (DiscreteUniformDistribution, DisclosureDiscreteUniform), - # (PoissonDistribution, DisclosurePoisson) - ] + [ + (UniformDistribution, DisclosureUniform), + (TruncatedNormalDistribution, DisclosureTruncatedNormal), + (NormalDistribution, DisclosureNormal), + (LogNormalDistribution, DisclosureLogNormal), + (ExponentialDistribution, DisclosureExponential), + (DiscreteUniformDistribution, DisclosureDiscreteUniform), + # (PoissonDistribution, DisclosurePoisson) + ], ) def test_continuous(dist_normal, dist_disclosure): unif = dist_normal.default_distribution() diff --git a/tests/test_other_dist.py b/tests/test_other_dist.py index 8aa5545..d7ca799 100644 --- a/tests/test_other_dist.py +++ b/tests/test_other_dist.py @@ -1,20 +1,26 @@ +import numpy as np import polars as pl -from metasyn.distribution.datetime import DateUniformDistribution -from metasyn.distribution.datetime import DateTimeUniformDistribution -from metasyn.distribution.datetime import TimeUniformDistribution -from metasyncontrib.disclosure.datetime import DisclosureDate, DisclosureDateTime, DisclosureTime -from pytest import mark from metasyn.distribution.categorical import MultinoulliDistribution +from metasyn.distribution.datetime import ( + DateTimeUniformDistribution, + DateUniformDistribution, + TimeUniformDistribution, +) +from pytest import mark + from metasyncontrib.disclosure.categorical import DisclosureMultinoulli -from metasyncontrib.disclosure.string import DisclosureFaker +from metasyncontrib.disclosure.datetime import DisclosureDate, DisclosureDateTime, DisclosureTime +from metasyncontrib.disclosure.faker import DisclosureFaker @mark.parametrize( "class_norm,class_disc", - [(DateUniformDistribution, DisclosureDate), - (DateTimeUniformDistribution, DisclosureDateTime), - (TimeUniformDistribution, DisclosureTime)] - ) + [ + (DateUniformDistribution, DisclosureDate), + (DateTimeUniformDistribution, DisclosureDateTime), + (TimeUniformDistribution, DisclosureTime), + ], +) def test_datetime(class_norm, class_disc): dist_norm = class_norm.default_distribution() series = pl.Series([dist_norm.draw() for _ in range(100)]) @@ -27,6 +33,7 @@ def test_datetime(class_norm, class_disc): def test_categorical(): + np.random.seed() dist_norm = MultinoulliDistribution.default_distribution() series = pl.Series([dist_norm.draw() for _ in range(40)], dtype=pl.Categorical) dist_norm = MultinoulliDistribution.fit(series) diff --git a/tests/test_provider.py b/tests/test_provider.py index c9fc35e..ad15543 100644 --- a/tests/test_provider.py +++ b/tests/test_provider.py @@ -1,7 +1,8 @@ -from pytest import mark - +import numpy as np from metasyn.provider import get_distribution_provider from metasyn.testutils import check_distribution, check_distribution_provider +from pytest import mark + from metasyncontrib.disclosure.privacy import DisclosurePrivacy @@ -9,13 +10,9 @@ def test_disclosure_provider(): check_distribution_provider("metasyn-disclosure") -@mark.parametrize( - "distribution", get_distribution_provider("metasyn-disclosure").distributions -) -@mark.parametrize( - "privacy_kwargs", ({}, {"n_avg": 10}, {"n_avg": 15}) -) +@mark.parametrize("distribution", get_distribution_provider("metasyn-disclosure").distributions) +@mark.parametrize("privacy_kwargs", ({}, {"n_avg": 10}, {"n_avg": 15})) def test_dist_validation(distribution, privacy_kwargs): + np.random.seed(45) privacy = DisclosurePrivacy(**privacy_kwargs) - check_distribution(distribution, privacy=privacy, - provenance="metasyn-disclosure") + check_distribution(distribution, privacy=privacy, provenance="metasyn-disclosure")