dbca-utils 2.0.3__py3-none-any.whl

dbca_utils/middleware.py

@@ -0,0 +1,179 @@
+from django import http, VERSION
+from django.conf import settings
+from django.contrib.auth import login, logout, get_user_model
+from django.utils.deprecation import MiddlewareMixin
+from django.utils.functional import SimpleLazyObject
+from django.utils import timezone
+from django.contrib.auth.middleware import AuthenticationMiddleware, get_user
+
+from dbca_utils.utils import env
+
+ENABLE_AUTH2_GROUPS = env("ENABLE_AUTH2_GROUPS", default=False)
+LOCAL_USERGROUPS = env("LOCAL_USERGROUPS", default=[])
+User = get_user_model()
+
+
+def sync_usergroups(user, groups):
+    from django.contrib.auth.models import Group
+
+    usergroups = (
+        [Group.objects.get_or_create(name=name)[0] for name in groups.split(",")] if groups else []
+    )
+    usergroups.sort(key=lambda o: o.id)
+    existing_usergroups = list(user.groups.exclude(name__in=LOCAL_USERGROUPS).order_by("id"))
+    index1 = 0
+    index2 = 0
+    len1 = len(usergroups)
+    len2 = len(existing_usergroups)
+
+    while True:
+        group1 = usergroups[index1] if index1 < len1 else None
+        group2 = existing_usergroups[index2] if index2 < len2 else None
+        if not group1 and not group2:
+            break
+        if not group1:
+            user.groups.remove(group2)
+            index2 += 1
+        elif not group2:
+            user.groups.add(group1)
+            index1 += 1
+        elif group1.id == group2.id:
+            index1 += 1
+            index2 += 1
+        elif group1.id < group2.id:
+            user.groups.add(group1)
+            index1 += 1
+        else:
+            user.groups.remove(group2)
+            index2 += 1
+
+
+class SimpleLazyUser(SimpleLazyObject):
+    def __init__(self, func, request, groups):
+        super().__init__(func)
+        self.request = request
+        self.usergroups = groups
+
+    def __getattr__(self, name):
+        if name == "groups":
+            sync_usergroups(self._wrapped, self.usergroups)
+            self.request.session["usergroups"] = self.usergroups
+
+        return super().__getattr__(name)
+
+
+# Monkey patch AuthenticationMiddleware to add logic to process user groups.
+if ENABLE_AUTH2_GROUPS:
+    original_process_request = AuthenticationMiddleware.process_request
+
+    def _process_request(self, request):
+        if "HTTP_X_GROUPS" in request.META:
+            groups = request.META["HTTP_X_GROUPS"] or None
+            existing_groups = request.session.get("usergroups")
+            if groups != existing_groups:
+                # User group is changed.
+                request.user = SimpleLazyUser(
+                    lambda: get_user(request), request, groups
+                )
+                return
+        original_process_request(self, request)
+
+    AuthenticationMiddleware.process_request = _process_request
+
+
+class SSOLoginMiddleware(MiddlewareMixin):
+    """Django middleware to process HTTP requests containing headers set by the Auth2
+    SSO service, specificially:
+    - `HTTP_REMOTE_USER`
+    - `HTTP_X_LAST_NAME`
+    - `HTTP_X_FIRST_NAME`
+    - `HTTP_X_EMAIL`
+    The middleware assesses requests containing these headers, and (having deferred user
+    authentication to the upstream service), retrieves the local Django User and logs
+    the user in automatically.
+    If the request path starts with one of the defined logout paths and a `HTTP_X_LOGOUT_URL`
+    value is set in the response, log out the user and redirect to that URL instead.
+    """
+
+    def process_request(self, request):
+
+        # Logout headers included with request.
+        if (
+            (
+                request.path.startswith("/logout")
+                or request.path.startswith("/admin/logout")
+                or request.path.startswith("/ledger/logout")
+            )
+            and "HTTP_X_LOGOUT_URL" in request.META
+            and request.META["HTTP_X_LOGOUT_URL"]
+        ):
+            logout(request)
+            return http.HttpResponseRedirect(request.META["HTTP_X_LOGOUT_URL"])
+
+        # Auth2 is not enabled, skip further processing.
+        if (
+            "HTTP_REMOTE_USER" not in request.META
+            or not request.META["HTTP_REMOTE_USER"]
+        ):
+            # auth2 not enabled
+            return
+
+        if VERSION < (2, 0):
+            user_authenticated = request.user.is_authenticated()
+        else:
+            user_authenticated = request.user.is_authenticated
+
+        # Auth2 is enabled.
+        # Request user is not authenticated.
+        if not user_authenticated:
+            attributemap = {
+                "username": "HTTP_REMOTE_USER",
+                "last_name": "HTTP_X_LAST_NAME",
+                "first_name": "HTTP_X_FIRST_NAME",
+                "email": "HTTP_X_EMAIL",
+            }
+
+            for key, value in attributemap.items():
+                if value in request.META:
+                    attributemap[key] = request.META[value]
+
+            # Optional setting: projects may define accepted user email domains either as
+            # a list of strings, or a single string.
+            if (
+                hasattr(settings, "ALLOWED_EMAIL_SUFFIXES")
+                and settings.ALLOWED_EMAIL_SUFFIXES
+            ):
+                allowed = settings.ALLOWED_EMAIL_SUFFIXES
+                if isinstance(settings.ALLOWED_EMAIL_SUFFIXES, str):
+                    allowed = [settings.ALLOWED_EMAIL_SUFFIXES]
+                if not any(
+                    [attributemap["email"].lower().endswith(x) for x in allowed]
+                ):
+                    return http.HttpResponseForbidden()
+
+            if (
+                attributemap["email"]
+                and User.objects.filter(email__iexact=attributemap["email"]).exists()
+            ):
+                user = User.objects.filter(email__iexact=attributemap["email"])[0]
+            elif (
+                User.__name__ != "EmailUser"
+                and User.objects.filter(username__iexact=attributemap["username"]).exists()
+            ):
+                user = User.objects.filter(username__iexact=attributemap["username"])[0]
+            else:
+                user = User(last_login=timezone.localtime())
+
+            # Set the user's details from the supplied information.
+            user.__dict__.update(attributemap)
+            user.save()
+            user.backend = "django.contrib.auth.backends.ModelBackend"
+
+            # Log the user in.
+            login(request, user)
+
+            # Synchronize the user groups
+            if ENABLE_AUTH2_GROUPS and "HTTP_X_GROUPS" in request.META:
+                groups = request.META["HTTP_X_GROUPS"] or None
+                sync_usergroups(user, groups)
+                request.session["usergroups"] = groups

dbca_utils/models.py

@@ -0,0 +1,97 @@
+from django.conf import settings
+from django.db import models
+from django.utils import timezone
+
+
+class ActiveMixinManager(models.Manager):
+    """Manager class for ActiveMixin."""
+
+    def current(self):
+        return self.filter(effective_to=None)
+
+    def deleted(self):
+        return self.filter(effective_to__isnull=False)
+
+
+class ActiveMixin(models.Model):
+    """Model mixin to allow objects to be saved as 'non-current' or 'inactive',
+    instead of deleting those objects.
+    The standard model delete() method is overridden.
+
+    "effective_to" is used to flag 'deleted' objects (not null==deleted).
+    """
+
+    effective_to = models.DateTimeField(null=True, blank=True)
+    objects = ActiveMixinManager()
+
+    class Meta:
+        abstract = True
+
+    def is_active(self):
+        return self.effective_to is None
+
+    def is_deleted(self):
+        return not self.is_active()
+
+    def delete(self, *args, **kwargs):
+        """Overide the standard delete method; sets effective_to the current
+        date and time.
+        """
+        if "force" in kwargs and kwargs["force"]:
+            kwargs.pop("force", None)
+            super(ActiveMixin, self).delete(*args, **kwargs)
+        else:
+            self.effective_to = timezone.now()
+            super(ActiveMixin, self).save(*args, **kwargs)
+
+
+class AuditMixin(models.Model):
+    """Model mixin to update creation/modification datestamp and user
+    automatically on save.
+    """
+
+    creator = models.ForeignKey(
+        settings.AUTH_USER_MODEL,
+        blank=True,
+        null=True,
+        on_delete=models.PROTECT,
+        related_name="%(app_label)s_%(class)s_created",
+        editable=False,
+    )
+    modifier = models.ForeignKey(
+        settings.AUTH_USER_MODEL,
+        blank=True,
+        null=True,
+        on_delete=models.PROTECT,
+        related_name="%(app_label)s_%(class)s_modified",
+        editable=False,
+    )
+    created = models.DateTimeField(default=timezone.now, editable=False)
+    modified = models.DateTimeField(auto_now=True, editable=False)
+
+    class Meta:
+        abstract = True
+
+    def __init__(self, *args, **kwargs):
+        super(AuditMixin, self).__init__(*args, **kwargs)
+        self._initial = {}
+        if self.pk:
+            for field in self._meta.fields:
+                self._initial[field.attname] = getattr(self, field.attname)
+
+    def has_changed(self):
+        """Returns True if the current data object differs from saved."""
+        return bool(self.changed_data)
+
+    @property
+    def changed_data(self):
+        """Returns a list of fields with data that differs from initial
+        values. May be utilised by revision mechanisms, as required.
+        """
+        self._changed_data = []
+        for field, value in self._initial.items():
+            if field in ["modified", "modifier_id"]:
+                continue  # Disregard modifer field as a test for changed data.
+            if getattr(self, field) != value:
+                self._changed_data.append(field)
+        return self._changed_data

dbca_utils/utils.py

@@ -0,0 +1,65 @@
+import ast
+import os
+
+
+def env(key, default=None, required=False, value_type=None):
+    """
+    Retrieves environment variables and returns Python natives. The (optional)
+    default will be returned if the environment variable does not exist.
+    """
+    try:
+        value = os.environ[key]
+        value = ast.literal_eval(value)
+    except (SyntaxError, ValueError):
+        pass
+    except KeyError:
+        if default is not None or not required:
+            return default
+        raise Exception(f"Missing required environment variable {key}")
+
+    if value_type is None:
+        if default is not None:
+            value_type = default.__class__
+
+    if value_type is None:
+        return value
+    elif isinstance(value, value_type):
+        return value
+    elif issubclass(value_type, list):
+        if isinstance(value, tuple):
+            return list(value)
+        else:
+            value = str(value).strip()
+            if not value:
+                return []
+            else:
+                return [s.strip() for s in value.split(",") if s.strip()]
+    elif issubclass(value_type, tuple):
+        if isinstance(value, list):
+            return tuple(value)
+        else:
+            value = str(value).strip()
+            if not value:
+                return tuple()
+            else:
+                return tuple([s.strip() for s in value.split(",") if s.strip()])
+    elif issubclass(value_type, bool):
+        value = str(value).strip()
+        if not value:
+            return False
+        elif value.lower() == "true":
+            return True
+        elif value.lower() == "false":
+            return False
+        else:
+            raise Exception(
+                f"{key} is a boolean environment variable and only accepts 'true' ,'false' and '' (case-insensitive), but the configured value is '{value}'"
+            )
+    elif issubclass(value_type, int):
+        return int(value)
+    elif issubclass(value_type, float):
+        return float(value)
+    else:
+        raise Exception(
+            f"{key} is a {value_type} environment variable, but {value_type} is not supported now"
+        )

dbca_utils-2.0.3.dist-info/LICENSE

@@ -0,0 +1,201 @@
+                                Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+1. Definitions.
+
+   "License" shall mean the terms and conditions for use, reproduction,
+   and distribution as defined by Sections 1 through 9 of this document.
+
+   "Licensor" shall mean the copyright owner or entity authorized by
+   the copyright owner that is granting the License.
+
+   "Legal Entity" shall mean the union of the acting entity and all
+   other entities that control, are controlled by, or are under common
+   control with that entity. For the purposes of this definition,
+   "control" means (i) the power, direct or indirect, to cause the
+   direction or management of such entity, whether by contract or
+   otherwise, or (ii) ownership of fifty percent (50%) or more of the
+   outstanding shares, or (iii) beneficial ownership of such entity.
+
+   "You" (or "Your") shall mean an individual or Legal Entity
+   exercising permissions granted by this License.
+
+   "Source" form shall mean the preferred form for making modifications,
+   including but not limited to software source code, documentation
+   source, and configuration files.
+
+   "Object" form shall mean any form resulting from mechanical
+   transformation or translation of a Source form, including but
+   not limited to compiled object code, generated documentation,
+   and conversions to other media types.
+
+   "Work" shall mean the work of authorship, whether in Source or
+   Object form, made available under the License, as indicated by a
+   copyright notice that is included in or attached to the work
+   (an example is provided in the Appendix below).
+
+   "Derivative Works" shall mean any work, whether in Source or Object
+   form, that is based on (or derived from) the Work and for which the
+   editorial revisions, annotations, elaborations, or other modifications
+   represent, as a whole, an original work of authorship. For the purposes
+   of this License, Derivative Works shall not include works that remain
+   separable from, or merely link (or bind by name) to the interfaces of,
+   the Work and Derivative Works thereof.
+
+   "Contribution" shall mean any work of authorship, including
+   the original version of the Work and any modifications or additions
+   to that Work or Derivative Works thereof, that is intentionally
+   submitted to Licensor for inclusion in the Work by the copyright owner
+   or by an individual or Legal Entity authorized to submit on behalf of
+   the copyright owner. For the purposes of this definition, "submitted"
+   means any form of electronic, verbal, or written communication sent
+   to the Licensor or its representatives, including but not limited to
+   communication on electronic mailing lists, source code control systems,
+   and issue tracking systems that are managed by, or on behalf of, the
+   Licensor for the purpose of discussing and improving the Work, but
+   excluding communication that is conspicuously marked or otherwise
+   designated in writing by the copyright owner as "Not a Contribution."
+
+   "Contributor" shall mean Licensor and any individual or Legal Entity
+   on behalf of whom a Contribution has been received by Licensor and
+   subsequently incorporated within the Work.
+
+2. Grant of Copyright License. Subject to the terms and conditions of
+   this License, each Contributor hereby grants to You a perpetual,
+   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+   copyright license to reproduce, prepare Derivative Works of,
+   publicly display, publicly perform, sublicense, and distribute the
+   Work and such Derivative Works in Source or Object form.
+
+3. Grant of Patent License. Subject to the terms and conditions of
+   this License, each Contributor hereby grants to You a perpetual,
+   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+   (except as stated in this section) patent license to make, have made,
+   use, offer to sell, sell, import, and otherwise transfer the Work,
+   where such license applies only to those patent claims licensable
+   by such Contributor that are necessarily infringed by their
+   Contribution(s) alone or by combination of their Contribution(s)
+   with the Work to which such Contribution(s) was submitted. If You
+   institute patent litigation against any entity (including a
+   cross-claim or counterclaim in a lawsuit) alleging that the Work
+   or a Contribution incorporated within the Work constitutes direct
+   or contributory patent infringement, then any patent licenses
+   granted to You under this License for that Work shall terminate
+   as of the date such litigation is filed.
+
+4. Redistribution. You may reproduce and distribute copies of the
+   Work or Derivative Works thereof in any medium, with or without
+   modifications, and in Source or Object form, provided that You
+   meet the following conditions:
+
+   (a) You must give any other recipients of the Work or
+   Derivative Works a copy of this License; and
+
+   (b) You must cause any modified files to carry prominent notices
+   stating that You changed the files; and
+
+   (c) You must retain, in the Source form of any Derivative Works
+   that You distribute, all copyright, patent, trademark, and
+   attribution notices from the Source form of the Work,
+   excluding those notices that do not pertain to any part of
+   the Derivative Works; and
+
+   (d) If the Work includes a "NOTICE" text file as part of its
+   distribution, then any Derivative Works that You distribute must
+   include a readable copy of the attribution notices contained
+   within such NOTICE file, excluding those notices that do not
+   pertain to any part of the Derivative Works, in at least one
+   of the following places: within a NOTICE text file distributed
+   as part of the Derivative Works; within the Source form or
+   documentation, if provided along with the Derivative Works; or,
+   within a display generated by the Derivative Works, if and
+   wherever such third-party notices normally appear. The contents
+   of the NOTICE file are for informational purposes only and
+   do not modify the License. You may add Your own attribution
+   notices within Derivative Works that You distribute, alongside
+   or as an addendum to the NOTICE text from the Work, provided
+   that such additional attribution notices cannot be construed
+   as modifying the License.
+
+   You may add Your own copyright statement to Your modifications and
+   may provide additional or different license terms and conditions
+   for use, reproduction, or distribution of Your modifications, or
+   for any such Derivative Works as a whole, provided Your use,
+   reproduction, and distribution of the Work otherwise complies with
+   the conditions stated in this License.
+
+5. Submission of Contributions. Unless You explicitly state otherwise,
+   any Contribution intentionally submitted for inclusion in the Work
+   by You to the Licensor shall be under the terms and conditions of
+   this License, without any additional terms or conditions.
+   Notwithstanding the above, nothing herein shall supersede or modify
+   the terms of any separate license agreement you may have executed
+   with Licensor regarding such Contributions.
+
+6. Trademarks. This License does not grant permission to use the trade
+   names, trademarks, service marks, or product names of the Licensor,
+   except as required for reasonable and customary use in describing the
+   origin of the Work and reproducing the content of the NOTICE file.
+
+7. Disclaimer of Warranty. Unless required by applicable law or
+   agreed to in writing, Licensor provides the Work (and each
+   Contributor provides its Contributions) on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+   implied, including, without limitation, any warranties or conditions
+   of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+   PARTICULAR PURPOSE. You are solely responsible for determining the
+   appropriateness of using or redistributing the Work and assume any
+   risks associated with Your exercise of permissions under this License.
+
+8. Limitation of Liability. In no event and under no legal theory,
+   whether in tort (including negligence), contract, or otherwise,
+   unless required by applicable law (such as deliberate and grossly
+   negligent acts) or agreed to in writing, shall any Contributor be
+   liable to You for damages, including any direct, indirect, special,
+   incidental, or consequential damages of any character arising as a
+   result of this License or out of the use or inability to use the
+   Work (including but not limited to damages for loss of goodwill,
+   work stoppage, computer failure or malfunction, or any and all
+   other commercial damages or losses), even if such Contributor
+   has been advised of the possibility of such damages.
+
+9. Accepting Warranty or Additional Liability. While redistributing
+   the Work or Derivative Works thereof, You may choose to offer,
+   and charge a fee for, acceptance of support, warranty, indemnity,
+   or other liability obligations and/or rights consistent with this
+   License. However, in accepting such obligations, You may act only
+   on Your own behalf and on Your sole responsibility, not on behalf
+   of any other Contributor, and only if You agree to indemnify,
+   defend, and hold each Contributor harmless for any liability
+   incurred by, or claims asserted against, such Contributor by reason
+   of your accepting any such warranty or additional liability.
+
+END OF TERMS AND CONDITIONS
+
+APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+Copyright [yyyy] [name of copyright owner]
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.

dbca_utils-2.0.3.dist-info/METADATA

@@ -0,0 +1,96 @@
+Metadata-Version: 2.1
+Name: dbca-utils
+Version: 2.0.3
+Summary: Utilities for DBCA Django apps
+License: Apache-2.0
+Author: Rocky Chen
+Author-email: rocky.chen@dbca.wa.gov.au
+Requires-Python: >=3.9,<4.0
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Environment :: Web Environment
+Classifier: Framework :: Django
+Classifier: Framework :: Django :: 3.2
+Classifier: Framework :: Django :: 4.0
+Classifier: Framework :: Django :: 4.2
+Classifier: Framework :: Django :: 5.0
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Software Development :: Libraries
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Dist: django (>=3.2,<5.1)
+Description-Content-Type: text/markdown
+
+# Overview
+
+DBCA Django utility classes and functions.
+
+## Development
+
+This project for development is using
+[Poetry](https://python-poetry.org/docs/) to install and manage a virtual Python
+environment. With Poetry installed, change into the project directory and run:
+
+    poetry install
+
+Activate the virtualenv like so:
+
+    poetry shell
+
+Run unit tests using `pytest` (or `tox`, to test against multiple Python versions):
+
+    pytest -v
+    tox -v
+
+## Releases
+
+Tagged releases are built and pushed to PyPI automatically using a GitHub
+workflow in the project. Update the project version in `pyproject.toml` and
+tag the required commit with the same value to trigger a release.
+
+## Installation
+
+1. Install via pip/Poetry/etc.: `pip install dbca-utils`
+
+## SSO Login Middleware
+
+This will automatically login and create users using headers from an upstream proxy (REMOTE_USER and some others).
+The logout view will redirect to a separate logout page which clears the SSO session.
+
+### Usage
+
+Add `dbca_utils.middleware.SSOLoginMiddleware` to `settings.MIDDLEWARE` (after both of
+`django.contrib.sessions.middleware.SessionMiddleware` and
+`django.contrib.auth.middleware.AuthenticationMiddleware`.
+Ensure that `AUTHENTICATION_BACKENDS` contains `django.contrib.auth.backends.ModelBackend`,
+as this middleware depends on it for retrieving the logged in user for a session.
+Note that the middleware will still work without it, but will reauthenticate the session
+on every request, and `request.user.is_authenticated` won't work properly/will be false.
+
+Example:
+
+```python
+MIDDLEWARE = [
+    ...,
+    'django.contrib.sessions.middleware.SessionMiddleware',
+    'django.contrib.auth.middleware.AuthenticationMiddleware',
+    'dbca_utils.middleware.SSOLoginMiddleware'
+    ...,
+]
+```
+
+## Audit model mixin
+
+`AuditMixin` is an extension of `Django.db.model.Model` that adds a number of additional fields:
+
+- creator - FK to `AUTH_USER_MODEL`, used to record the object creator
+- modifier - FK to `AUTH_USER_MODEL`, used to record who the object was last modified by
+- created - a timestamp that is set on initial object save
+- modified - an auto-updating timestamp (on each object save)
+

dbca_utils-2.0.3.dist-info/RECORD

@@ -0,0 +1,8 @@
+dbca_utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+dbca_utils/middleware.py,sha256=h8_Eg31CI7UJ3QY6d5HOkT4RvaaXGbkh-2Me-nLLy-g,6623
+dbca_utils/models.py,sha256=tb-_dxYXbh7pT_q1qo1pC4AKCX7wq8nq2k7anrY6MNI,3036
+dbca_utils/utils.py,sha256=XnwDCr2-09ffyGlc8hSk_yiVGpWnJXkRrgCl9WivGKc,2123
+dbca_utils-2.0.3.dist-info/LICENSE,sha256=hQNdSQ5JD3TmzgScnDLFrwFybIj5bZgwHXXoz4sDX-w,10801
+dbca_utils-2.0.3.dist-info/METADATA,sha256=h4855afmCYWrRn4lCCGUR6T-yjLD79Lvcw38ShJSxnE,3331
+dbca_utils-2.0.3.dist-info/WHEEL,sha256=Nq82e9rUAnEjt98J6MlVmMCZb-t9cYE2Ir1kpBmnWfs,88
+dbca_utils-2.0.3.dist-info/RECORD,,

dbca_utils-2.0.3.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: poetry-core 1.9.1
+Root-Is-Purelib: true
+Tag: py3-none-any