sortinghat-eclipse-foundation 0.1.0__py3-none-any.whl

sortinghat/core/importer/backends/_version.py

@@ -0,0 +1,2 @@
+# File auto-generated by semverup on 2025-09-24 13:34:43.468109
+__version__ = "0.1.0"

sortinghat/core/importer/backends/eclipse.py

@@ -0,0 +1,355 @@
+# -*- coding: utf-8 -*-
+#
+# Copyright 2025-present Bitergia
+#
+# 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.
+#
+
+import logging
+
+import dateutil.relativedelta
+import requests
+
+from django.conf import settings
+from django.db.models import (Q, Subquery)
+
+from requests_oauth2client import OAuth2Client
+from requests_oauth2client.tokens import ExpiredAccessToken
+
+from grimoirelab_toolkit.datetime import (
+    str_to_datetime,
+    datetime_utcnow
+)
+from sortinghat.core.importer.backend import IdentitiesImporter
+from sortinghat.core.importer.models import (
+    Individual,
+    Identity,
+    Enrollment,
+    Organization,
+    Profile,
+)
+from sortinghat.core import api
+from sortinghat.core import models as sh_models
+
+
+# Data source types
+ECLIPSE_SOURCE = "eclipsefdn"
+GITHUB_SOURCE = "github"
+
+
+logger = logging.getLogger(__name__)
+
+
+class EclipseFoundationAccountsImporter(IdentitiesImporter):
+    """Imports identities from the Eclipse Foundation platform.
+
+    The importer fetches and stores in the database identities
+    created or updated after the given date (`from_date`) parameter.
+    Currently, it can only import identities updated since a year ago.
+    When no date is given, it will import all the identities updated
+    since last year.
+
+    Each individual created after importing will have two identities:
+    one with source set as 'eclipsefdn' that includes their name, email
+    and username as it comes from the platform, and a second one with
+    source 'github' only when the github user was set by the identity
+    on the Eclipse profile.
+
+    :param ctx: SortingHat context
+    :param url: not used on this importer
+    :param from_date: start fetching identities updated from this date
+
+    :raises ValueError: when the date is older than one year ago
+    """
+    NAME = "EclipseFoundation"
+
+    def __init__(self, ctx, url, from_date=None):
+        super().__init__(ctx, url)
+
+        min_date = datetime_utcnow() - dateutil.relativedelta.relativedelta(years=1)
+
+        if not from_date:
+            self.from_date = min_date
+        elif isinstance(from_date, str):
+            self.from_date = str_to_datetime(from_date)
+        else:
+            self.from_date = from_date
+
+        if self.from_date < min_date:
+            msg = (
+                "Invalid 'from_date' value. It can only import identities updated since a year ago."
+                "from_date=" + from_date
+            )
+            logger.error(msg)
+            raise ValueError(msg)
+
+    def get_individuals(self):
+        """Get the individuals from the Eclipse Foundation platform."""
+
+        user_id = getattr(settings, 'ECLIPSE_FOUNDATION_USER_ID', None)
+        password = getattr(settings, 'ECLIPSE_FOUNDATION_PASSWORD', None)
+
+        client = EclipseFoundationAPIClient()
+        client.login(user_id, password)
+
+        epoch = int(self.from_date.timestamp())
+
+        # Fetch accounts pages
+        for account in client.fetch_accounts(epoch=epoch):
+            ef_profile = client.fetch_account_profile(account['name'])
+
+            if not ef_profile:
+                continue
+
+            individual = Individual(uuid=ef_profile['uid'])
+
+            name = ef_profile['first_name'] + ' ' + ef_profile['last_name']
+            email = ef_profile['mail']
+
+            prf = Profile()
+            prf.name = name
+            prf.email = email
+
+            individual.profile = prf
+
+            eclipse_id = Identity(
+                source=ECLIPSE_SOURCE,
+                name=name,
+                email=email,
+                username=ef_profile['name'],
+            )
+            individual.identities.append(eclipse_id)
+
+            if ef_profile['github_handle']:
+                idt = Identity(
+                    source=GITHUB_SOURCE,
+                    name=name,
+                    username=ef_profile['github_handle'],
+                    email=email,
+                )
+                individual.identities.append(idt)
+
+            # Fetch enrollments for the identity. If no enrollment is set
+            # use the organization field from the profile, if set.
+            employment_history = client.fetch_employment_history(account['name'])
+
+            if employment_history:
+                for employment in employment_history:
+                    org = Organization(name=employment['organization_name'])
+                    start, end = None, None
+
+                    if employment['start']:
+                        start = str_to_datetime(employment['start'])
+                    if employment['end']:
+                        end = str_to_datetime(employment['end'])
+
+                    enr = Enrollment(org, start=start, end=end)
+                    individual.enrollments.append(enr)
+
+            if not individual.enrollments:
+                company = ef_profile.get('org', None)
+                if company:
+                    org = Organization(name=company)
+                    enr = Enrollment(org)
+                    individual.enrollments.append(enr)
+
+            logger.info(f"Eclipse account processed; account={account['name']}; changed={account['changed']}")
+
+            yield individual
+
+    def post_process_individual(self, individual, uuid):
+        """Post processing for Eclipse identities.
+
+        The method tries to find Eclipse or GitHub identities
+        already imported to merge them with the given individual.
+        When that happens the profile will be the Eclipse individual's
+        one.
+        """
+        eclipse_identity = None
+
+        for identity in individual.identities:
+            if identity.source == ECLIPSE_SOURCE and identity.email and identity.username:
+                eclipse_identity = identity
+                break
+
+        if not eclipse_identity:
+            return
+
+        query = sh_models.Individual.objects.filter(
+            mk__in=Subquery(
+                sh_models.Identity.objects.filter(
+                    Q(email=eclipse_identity.email) |
+                    (Q(username=eclipse_identity.username) & Q(source='github'))
+                ).exclude(uuid=uuid).values_list('individual__mk')
+            )
+        ).exclude(mk=uuid).values_list('mk')
+
+        from_uuids = [entry[0] for entry in query.all()]
+
+        if from_uuids:
+            api.merge(self.ctx, from_uuids, uuid)
+
+
+class EclipseFoundationAPIClient:
+    """Eclipse Foundation's Profile API client."""
+
+    ECLIPSE_API_URL = "https://api.eclipse.org"
+    ECLIPSE_ACCOUNTS_URL = "https://accounts.eclipse.org"
+    OAUTH_TOKEN_ENDPOINT = "https://accounts.eclipse.org/oauth2/token"
+    ECLIPSE_SCOPE = "eclipsefdn_view_all_profiles"
+
+    MAX_RETRIES = 3
+
+    def __init__(self):
+        self.token = None
+        self.user_id = None
+        self.password = None
+
+    def login(self, user_id, password):
+        """Login on the Eclipse platform.
+
+        The authentication method is OAuth2. We use the scope
+        "eclipsefdn_view_all_profiles" that will allow us to
+        fetch all the info about profiles/identities.
+        """
+        self.user_id = user_id
+        self.password = password
+        self.token = self._authenticate(
+            self.user_id,
+            self.password,
+            self.ECLIPSE_SCOPE,
+        )
+
+    def logout(self):
+        """Logout from the Eclipse platform."""
+
+        self.token = None
+
+    def fetch_accounts(self, epoch):
+        """Fetch accounts updated from a given UNIX time."""
+
+        page = 1
+        total_accounts = 0
+
+        logger.info(f"Fetching accounts from API; url={self.ECLIPSE_ACCOUNTS_URL}, epoch={epoch}")
+
+        while True:
+            url = f"{self.ECLIPSE_ACCOUNTS_URL}/account/updated"
+            params = {
+                'since': epoch,
+                'page': page
+            }
+
+            logger.debug(f"Fetching accounts from API; url={url}, params={params}")
+            data = self._fetch(url, params=params)
+
+            for account in data['result']:
+                yield account
+
+            naccounts = len(data['result'])
+            total_accounts += naccounts
+
+            logger.debug(f"Accounts from API fetched; url={url}, params={params}, naccounts={naccounts}")
+
+            if page >= data['pagination']['result_end']:
+                break
+
+            page += 1
+
+        logger.info(f"Accounts fetched from API; url={url}, epoch={epoch}, total_accounts={total_accounts}")
+
+    def fetch_account_profile(self, eclipsefdn_id):
+        """Get the profile of the given identity."""
+
+        url = f"{self.ECLIPSE_API_URL}/account/profile/{eclipsefdn_id}"
+        data = self._fetch(url)
+        logger.info(f"Profile fetched; url={url}, eclipsefdn_id={eclipsefdn_id}")
+        return data
+
+    def fetch_employment_history(self, eclipsefdn_id):
+        """Get the employment history of the given identity."""
+
+        url = f"{self.ECLIPSE_API_URL}/account/profile/{eclipsefdn_id}/employment-history"
+        data = self._fetch(url)
+        logger.info(f"Employment history fetched; url={url}, eclipsefdn_id={eclipsefdn_id}")
+        return data
+
+    def _fetch(self, url, params=None):
+        """Generic query to Eclipse usr API."""
+
+        try:
+            data = self._fetch_retry(url, params)
+        except requests.exceptions.HTTPError as error:
+            # Ignore 5xx errors
+            if 500 <= error.response.status_code < 600:
+                msg = (
+                    f"Unable to fetch {url}"
+                    f"Server error: {error.response.status_code} - {error.response.reason}."
+                    "Skipping"
+                )
+                logger.error(msg)
+                return None
+            else:
+                raise error
+
+        return data
+
+    def _fetch_retry(self, url, params=None):
+        """Fetch URL retrying in case of 403 or 500 errors.
+
+        When getting a 403 error, the method will try to authenticate
+        again in case the OAuth2 token has expired.
+        """
+        retries = 0
+        max_retries = self.MAX_RETRIES
+
+        while retries < max_retries:
+            try:
+                response = requests.get(url, params=params, auth=self.token)
+            except ExpiredAccessToken:
+                # Refresh token and try again
+                self.login(self.user_id, self.password)
+                retries += 1
+                continue
+
+            if response.status_code == 200:
+                return response.json()
+            elif response.status_code == 403:
+                if self.token.expires_at <= datetime_utcnow():
+                    self.login(self.user_id, self.password)
+                retries += 1
+            elif 500 <= response.status_code < 600:
+                # Errors could have been related to server overloading
+                retries += 1
+            else:
+                response.raise_for_status()
+
+        response = requests.get(url, params=params, auth=self.token)
+        response.raise_for_status()
+
+        return response
+
+    def _authenticate(self, client_id, client_secret, scope):
+        """Authenticate using OAuth2.
+
+        After authenticating, returns a Bearer token that can be used
+        in the API requests.
+        """
+        oauth2client = OAuth2Client(
+            token_endpoint=self.OAUTH_TOKEN_ENDPOINT,
+            client_id=client_id,
+            client_secret=client_secret,
+        )
+        token = oauth2client.client_credentials(scope=scope)
+
+        return token

sortinghat_eclipse_foundation-0.1.0.dist-info/METADATA

@@ -0,0 +1,91 @@
+Metadata-Version: 2.4
+Name: sortinghat-eclipse-foundation
+Version: 0.1.0
+Summary: SortingHat backend to import identities from the Eclipse Foundation
+License-File: AUTHORS
+License-File: LICENSE.txt
+Keywords: development,grimoirelab,sortinghat
+Author: Bitergia Developers
+Requires-Python: >=3.10,<4.0
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+Classifier: Topic :: Software Development
+Classifier: Programming Language :: Python :: 3
+Requires-Dist: requests-oauth2client (>=1.7.0,<2.0.0)
+Requires-Dist: sortinghat (>=1.10.0,<2.0.0)
+Description-Content-Type: text/markdown
+
+# sortinghat-eclipse-foundation
+
+SortingHat backend to import identities from Eclipse Foundation
+
+## Requirements
+
+ - Python >= 3.9
+
+You will also need some other libraries for running the tool, you can find the
+whole list of dependencies in [pyproject.toml](pyproject.toml) file.
+
+## Installation
+
+There are several ways to install sortinghat-eclipse-foundation on your system: packages or source
+code using Poetry or pip.
+
+### PyPI
+
+sortinghat-eclipse-foundation can be installed using pip, a tool for installing Python packages.
+To do it, run the next command:
+```
+$ pip install sortinghat-eclipse-foundation
+```
+
+### Source code
+
+To install from the source code you will need to clone the repository first:
+```
+$ git clone https://github.com/bitergia-analytics/sortinghat-eclipse-foundation
+$ cd sortinghat-eclipse-foundation
+```
+
+Then use pip or Poetry to install the package along with its dependencies.
+
+#### Pip
+
+To install the package from local directory run the following command:
+```
+$ pip install .
+```
+In case you are a developer, you should install sortinghat-eclipse-foundation in editable mode:
+```
+$ pip install -e .
+```
+
+#### Poetry
+
+We use [poetry](https://python-poetry.org/) for dependency management and
+packaging. You can install it following its [documentation](https://python-poetry.org/docs/#installation).
+Once you have installed it, you can install sortinghat-openinfra and the dependencies in
+a project isolated environment using:
+```
+$ poetry install
+```
+To spaw a new shell within the virtual environment use:
+```
+$ poetry shell
+```
+
+## Usage
+
+Install this SortingHat backend to import identities from the Eclipse Foundation.
+You can use this importer using the API or the UI. The name of the backend is
+`EclipseFoundation`. You will have to provide the credentials on the settings file
+in order to access the Eclipse Foundation API:
+
+- `ECLIPSE_FOUNDATION_USER_ID`: username on the Eclipse Foundation platform.
+- `ECLIPSE_FOUNDATION_PASSWORD`: password for the previous user.
+
+The user will also have the next permissions for reading the identities:
+
+- `eclipsefdn_view_all_profiles`
+

sortinghat_eclipse_foundation-0.1.0.dist-info/RECORD

@@ -0,0 +1,7 @@
+sortinghat/core/importer/backends/_version.py,sha256=iQdCKUd98-Lf57yM9KVG3Jr9tKN2cZ-snl7U4SUW4vE,86
+sortinghat/core/importer/backends/eclipse.py,sha256=cG_Mwewbrm3hCf3WN0x2P-iBrhDbeWk0LajI6RUyw-g,11876
+sortinghat_eclipse_foundation-0.1.0.dist-info/METADATA,sha256=i8ChRp-646cOLxQHJsW5--f80iwdRe2eQyKKqxaETOE,2784
+sortinghat_eclipse_foundation-0.1.0.dist-info/WHEEL,sha256=zp0Cn7JsFoX2ATtOhtaFYIiE2rmFAD4OcMhtUki8W3U,88
+sortinghat_eclipse_foundation-0.1.0.dist-info/licenses/AUTHORS,sha256=ZI6cTLoNghfhkYwFzkIRwIAIMkG-xsmQEudrKK6Ez4E,90
+sortinghat_eclipse_foundation-0.1.0.dist-info/licenses/LICENSE.txt,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+sortinghat_eclipse_foundation-0.1.0.dist-info/RECORD,,

sortinghat_eclipse_foundation-0.1.0.dist-info/WHEEL

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

sortinghat_eclipse_foundation-0.1.0.dist-info/licenses/AUTHORS

@@ -0,0 +1,3 @@
+Jose Javier Merchante <jjmerchante@bitergia.com>
+Santiago Dueñas <sduenas@bitergia.com>
+

sortinghat_eclipse_foundation-0.1.0.dist-info/licenses/LICENSE.txt

@@ -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.