netbox-eosl 0.1.0__tar.gz

netbox_eosl-0.1.0/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 2026 EOSL.ai
+
+   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.

netbox_eosl-0.1.0/MANIFEST.in

@@ -0,0 +1,3 @@
+include LICENSE
+include README.md
+recursive-include netbox_eosl/templates *.html

netbox_eosl-0.1.0/PKG-INFO

@@ -0,0 +1,145 @@
+Metadata-Version: 2.4
+Name: netbox-eosl
+Version: 0.1.0
+Summary: Show source-backed hardware end-of-service-life status on NetBox Devices and Device Types, from EOSL.ai.
+Author-email: "EOSL.ai" <hello@eosl.ai>
+License: Apache-2.0
+Project-URL: Homepage, https://eosl.ai/
+Project-URL: Data source, https://eosl.ai/api/
+Project-URL: Source, https://github.com/Kranny36/netbox-eosl
+Keywords: netbox,netbox-plugin,eosl,end-of-life,eol,lifecycle,dcim
+Classifier: Framework :: Django
+Classifier: Intended Audience :: System Administrators
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: System :: Networking :: Monitoring
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: requests>=2.25
+Dynamic: license-file
+
+# netbox-eosl
+
+Show **source-backed hardware end-of-service-life (EOSL) status** on your NetBox Devices and
+Device Types, straight from [EOSL.ai](https://eosl.ai) — where every date links to the vendor's
+own end-of-life bulletin.
+
+A panel appears on the right side of each Device and Device Type page: end-of-sale date,
+end-of-service-life date, the EOSL Exposure Score, a link to the vendor bulletin, and a link to
+the full EOSL.ai model page. A `manage.py eosl_check` command audits your whole inventory.
+
+Matching is **exact part-number only** — the plugin never fuzzy-matches, so it can't put a wrong
+end-of-life date on the wrong device. If a part number isn't in the database, it says so and
+offers a search link instead of guessing.
+
+## Requirements
+
+| | |
+|---|---|
+| NetBox | **4.3** or later (uses the `models` template-extension API) |
+| Python | 3.10+ |
+| Network | outbound HTTPS to `eosl.ai` from the NetBox host |
+
+## Install
+
+```bash
+# In your NetBox virtual environment
+source /opt/netbox/venv/bin/activate
+pip install netbox-eosl
+```
+
+Add it to NetBox's `configuration.py`:
+
+```python
+PLUGINS = [
+    "netbox_eosl",
+]
+```
+
+(Optional) tune it:
+
+```python
+PLUGINS_CONFIG = {
+    "netbox_eosl": {
+        "api_url": "https://eosl.ai",   # data source origin
+        "cache_timeout": 86400,          # seconds to cache the lookup table (default 24h)
+        "request_timeout": 5,            # network timeout in seconds
+    },
+}
+```
+
+Then restart NetBox and run migrations (none are added, but this reloads plugins):
+
+```bash
+python /opt/netbox/netbox/manage.py migrate
+sudo systemctl restart netbox netbox-rq
+```
+
+Add `netbox-eosl` to your `local_requirements.txt` so upgrades keep it installed.
+
+## Use
+
+**In the UI** — open any Device or Device Type that has a **part number** set. The
+"Hardware End-of-Life" card appears in the right column.
+
+**Inventory audit** — from the NetBox host:
+
+```bash
+python /opt/netbox/netbox/manage.py eosl_check
+```
+
+```
+EOSL.ai audit — 214 device types
+  Past / action recommended:       57
+  Ending soon (plan/watch):        18
+  Tracked, supported:              44
+  Active — no EOL announced:        9
+  Not found in EOSL.ai:            79
+  No part number set:               7
+
+Past end-of-service-life:
+  Cisco Catalyst 3850-48P (WS-C3850-48P-S) — EOSL 2025-10 — 12 in service — https://eosl.ai/system/cisco-catalyst-3850/
+  ...
+```
+
+Use `--past-only` to print just the past-EOSL list (handy in a cron/report).
+
+## How matching works
+
+The plugin downloads `https://eosl.ai/data/lookup.json` (the same part-number → status map that
+powers the eosl.ai bulk checker) and caches it. For each Device Type it resolves the `part_number`
+field (a Device inherits it from its Device Type) in three deterministic, conservative steps:
+
+1. **Exact** match (case-insensitive).
+2. **Loose** match — ignores spaces/dashes/case, so `FortiGate 60E` resolves `FortiGate-60E`.
+3. **Vendor-gated aliases** — expands a manufacturer's short SKU form to the catalogued long form,
+   but **only when the NetBox manufacturer matches that vendor**. E.g. a Fortinet `FG-60E` resolves
+   `FortiGate-60E`, `FS-148E` → `FortiSwitch-148E`, `FAP-221E` → `FortiAP-221E`. The vendor gate means
+   a non-Fortinet `FG-…` can never be mis-resolved onto a Fortinet record.
+
+There is **no fuzzy or substring matching**. No part number, or no confident match → a neutral
+"not tracked" panel with a search link. Nothing is inferred.
+
+The matching logic lives in `netbox_eosl/matching.py` (no Django imports) and is unit-tested in
+`tests/` — run `python tests/test_matching.py` (or `pytest`).
+
+## Data & trust
+
+- Dates come from EOSL.ai, sourced from each vendor's official end-of-life bulletin and linked
+  for verification. Where a vendor publishes no per-model EOSL date, EOSL.ai computes it from the
+  vendor's published support-life policy and labels it "computed".
+- This plugin **reads** public data; it sends none of your inventory anywhere. The only outbound
+  request is fetching the public lookup table.
+- Confirm any critical date against the linked vendor bulletin before a purchase, renewal, or
+  migration decision.
+
+## License
+
+Apache-2.0. See `LICENSE`.
+
+## Contributing / publishing
+
+Issues and PRs welcome — especially additional vendor SKU aliases (see `FORTINET_PREFIX` in
+`matching.py` for the pattern) and screenshots. Maintainers: see `PUBLISHING.md` for the
+PyPI + NetBox-community release steps.

netbox_eosl-0.1.0/README.md

@@ -0,0 +1,124 @@
+# netbox-eosl
+
+Show **source-backed hardware end-of-service-life (EOSL) status** on your NetBox Devices and
+Device Types, straight from [EOSL.ai](https://eosl.ai) — where every date links to the vendor's
+own end-of-life bulletin.
+
+A panel appears on the right side of each Device and Device Type page: end-of-sale date,
+end-of-service-life date, the EOSL Exposure Score, a link to the vendor bulletin, and a link to
+the full EOSL.ai model page. A `manage.py eosl_check` command audits your whole inventory.
+
+Matching is **exact part-number only** — the plugin never fuzzy-matches, so it can't put a wrong
+end-of-life date on the wrong device. If a part number isn't in the database, it says so and
+offers a search link instead of guessing.
+
+## Requirements
+
+| | |
+|---|---|
+| NetBox | **4.3** or later (uses the `models` template-extension API) |
+| Python | 3.10+ |
+| Network | outbound HTTPS to `eosl.ai` from the NetBox host |
+
+## Install
+
+```bash
+# In your NetBox virtual environment
+source /opt/netbox/venv/bin/activate
+pip install netbox-eosl
+```
+
+Add it to NetBox's `configuration.py`:
+
+```python
+PLUGINS = [
+    "netbox_eosl",
+]
+```
+
+(Optional) tune it:
+
+```python
+PLUGINS_CONFIG = {
+    "netbox_eosl": {
+        "api_url": "https://eosl.ai",   # data source origin
+        "cache_timeout": 86400,          # seconds to cache the lookup table (default 24h)
+        "request_timeout": 5,            # network timeout in seconds
+    },
+}
+```
+
+Then restart NetBox and run migrations (none are added, but this reloads plugins):
+
+```bash
+python /opt/netbox/netbox/manage.py migrate
+sudo systemctl restart netbox netbox-rq
+```
+
+Add `netbox-eosl` to your `local_requirements.txt` so upgrades keep it installed.
+
+## Use
+
+**In the UI** — open any Device or Device Type that has a **part number** set. The
+"Hardware End-of-Life" card appears in the right column.
+
+**Inventory audit** — from the NetBox host:
+
+```bash
+python /opt/netbox/netbox/manage.py eosl_check
+```
+
+```
+EOSL.ai audit — 214 device types
+  Past / action recommended:       57
+  Ending soon (plan/watch):        18
+  Tracked, supported:              44
+  Active — no EOL announced:        9
+  Not found in EOSL.ai:            79
+  No part number set:               7
+
+Past end-of-service-life:
+  Cisco Catalyst 3850-48P (WS-C3850-48P-S) — EOSL 2025-10 — 12 in service — https://eosl.ai/system/cisco-catalyst-3850/
+  ...
+```
+
+Use `--past-only` to print just the past-EOSL list (handy in a cron/report).
+
+## How matching works
+
+The plugin downloads `https://eosl.ai/data/lookup.json` (the same part-number → status map that
+powers the eosl.ai bulk checker) and caches it. For each Device Type it resolves the `part_number`
+field (a Device inherits it from its Device Type) in three deterministic, conservative steps:
+
+1. **Exact** match (case-insensitive).
+2. **Loose** match — ignores spaces/dashes/case, so `FortiGate 60E` resolves `FortiGate-60E`.
+3. **Vendor-gated aliases** — expands a manufacturer's short SKU form to the catalogued long form,
+   but **only when the NetBox manufacturer matches that vendor**. E.g. a Fortinet `FG-60E` resolves
+   `FortiGate-60E`, `FS-148E` → `FortiSwitch-148E`, `FAP-221E` → `FortiAP-221E`. The vendor gate means
+   a non-Fortinet `FG-…` can never be mis-resolved onto a Fortinet record.
+
+There is **no fuzzy or substring matching**. No part number, or no confident match → a neutral
+"not tracked" panel with a search link. Nothing is inferred.
+
+The matching logic lives in `netbox_eosl/matching.py` (no Django imports) and is unit-tested in
+`tests/` — run `python tests/test_matching.py` (or `pytest`).
+
+## Data & trust
+
+- Dates come from EOSL.ai, sourced from each vendor's official end-of-life bulletin and linked
+  for verification. Where a vendor publishes no per-model EOSL date, EOSL.ai computes it from the
+  vendor's published support-life policy and labels it "computed".
+- This plugin **reads** public data; it sends none of your inventory anywhere. The only outbound
+  request is fetching the public lookup table.
+- Confirm any critical date against the linked vendor bulletin before a purchase, renewal, or
+  migration decision.
+
+## License
+
+Apache-2.0. See `LICENSE`.
+
+## Contributing / publishing
+
+Issues and PRs welcome — especially additional vendor SKU aliases (see `FORTINET_PREFIX` in
+`matching.py` for the pattern) and screenshots. Maintainers: see `PUBLISHING.md` for the
+PyPI + NetBox-community release steps.

netbox_eosl-0.1.0/netbox_eosl/__init__.py

@@ -0,0 +1,32 @@
+"""netbox-eosl — surface source-backed hardware end-of-service-life status inside NetBox.
+
+Data comes from EOSL.ai's public API (https://eosl.ai), where every date links to the
+vendor's own end-of-life bulletin. Matching is exact part-number only — the plugin never
+guesses, so it cannot assert an end-of-life date NetBox isn't certain about.
+"""
+from netbox.plugins import PluginConfig
+
+__version__ = "0.1.0"
+
+
+class EOSLConfig(PluginConfig):
+    name = "netbox_eosl"
+    verbose_name = "EOSL.ai — Hardware End-of-Life"
+    description = "Show source-backed end-of-sale / end-of-service-life status on Devices and Device Types, from EOSL.ai."
+    version = __version__
+    author = "EOSL.ai"
+    author_email = "hello@eosl.ai"
+    base_url = "eosl"
+    # PluginTemplateExtension.models (plural) is required from NetBox 4.3 onward.
+    min_version = "4.3.0"
+    default_settings = {
+        # Base origin of the EOSL.ai data source. Override only if you mirror the dataset.
+        "api_url": "https://eosl.ai",
+        # How long (seconds) to cache the downloaded lookup table. Default: 24h.
+        "cache_timeout": 86400,
+        # Network timeout (seconds) for fetching the lookup table.
+        "request_timeout": 5,
+    }
+
+
+config = EOSLConfig

netbox_eosl-0.1.0/netbox_eosl/client.py

@@ -0,0 +1,95 @@
+"""Client for the EOSL.ai public lookup dataset.
+
+Downloads https://eosl.ai/data/lookup.json (the same compact part-number -> status map that powers
+the eosl.ai bulk checker), caches it, and resolves a part number to its lifecycle record via the
+deterministic, vendor-gated matcher in `matching.py`. Never fuzzy-matches — a wrong end-of-life date
+on the wrong device would defeat the point of a source-backed tool.
+"""
+import logging
+
+import requests
+from django.core.cache import cache
+from netbox.plugins import get_plugin_config
+
+from . import matching
+
+logger = logging.getLogger("netbox.plugins.netbox_eosl")
+
+_SKU_CACHE_KEY = "netbox_eosl:skus:v2"
+# In-process memo of the built indexes, rebuilt only when the sku set changes.
+_MEMO = {"token": None, "idx": (None, None)}
+
+
+def _cfg(key):
+    return get_plugin_config("netbox_eosl", key)
+
+
+def _load_skus():
+    """Return the list of sku records from EOSL.ai, cached. [] on any failure (never raises)."""
+    skus = cache.get(_SKU_CACHE_KEY)
+    if skus is not None:
+        return skus
+
+    url = _cfg("api_url").rstrip("/") + "/data/lookup.json"
+    try:
+        resp = requests.get(
+            url,
+            timeout=_cfg("request_timeout"),
+            headers={"User-Agent": "netbox-eosl/0.1 (+https://eosl.ai)"},
+        )
+        resp.raise_for_status()
+        skus = resp.json().get("skus", [])
+    except (requests.RequestException, ValueError) as exc:
+        logger.warning("netbox-eosl: could not load lookup data from %s: %s", url, exc)
+        cache.set(_SKU_CACHE_KEY, [], 300)  # brief negative cache so a broken upstream isn't hammered
+        return []
+
+    cache.set(_SKU_CACHE_KEY, skus, _cfg("cache_timeout"))
+    return skus
+
+
+def _indexes():
+    """(exact, loose) indexes, rebuilt in-process only when the sku count changes."""
+    skus = _load_skus()
+    token = len(skus)
+    if _MEMO["token"] != token:
+        _MEMO["token"] = token
+        _MEMO["idx"] = matching.build_index(skus)
+    return _MEMO["idx"]
+
+
+def lookup_part(part_number, vendor=None):
+    """Resolve one part number (optionally with its NetBox manufacturer name) to a display dict, or None.
+
+    Passing `vendor` enables vendor-gated aliases (e.g. Fortinet FG-60E -> FortiGate-60E) without risking
+    a cross-vendor false match. The returned dict is safe to hand straight to the template.
+    """
+    if not part_number:
+        return None
+    exact, loose_index = _indexes()
+    rec = matching.match(part_number, vendor, exact, loose_index)
+    if not rec:
+        return None
+    state, label, css = matching.classify(rec)
+    slug = rec.get("s")
+    return {
+        "part": rec.get("p"),
+        "vendor": rec.get("v"),
+        "family": rec.get("f"),
+        "end_of_sale": rec.get("eos"),
+        "eosl": rec.get("eol"),
+        "source_url": rec.get("src"),
+        "exposure_score": rec.get("xs"),
+        "exposure_band": rec.get("xb"),
+        "active": bool(rec.get("a")),
+        "state": state,
+        "state_label": label,
+        "state_css": css,
+        "page_url": (_cfg("api_url").rstrip("/") + "/system/" + slug + "/") if slug else _cfg("api_url"),
+    }
+
+
+def search_url(term):
+    """A safe fallback link into eosl.ai when we have no exact match."""
+    base = _cfg("api_url").rstrip("/")
+    return "{}/?q={}".format(base, requests.utils.quote(term or ""))

netbox_eosl-0.1.0/netbox_eosl/management/commands/eosl_check.py

@@ -0,0 +1,79 @@
+"""`manage.py eosl_check` — audit your NetBox device types against EOSL.ai.
+
+Prints a summary of how many tracked device types are past end-of-service-life, ending soon,
+still active, or not found in the EOSL.ai database — plus the list of past-EOSL types with how
+many device instances you run. Read-only; changes nothing in NetBox.
+"""
+from collections import Counter
+
+from dcim.models import DeviceType
+from django.core.management.base import BaseCommand
+
+from netbox_eosl.client import lookup_part
+
+
+class Command(BaseCommand):
+    help = "Audit NetBox device types against EOSL.ai end-of-life data (read-only)."
+
+    def add_arguments(self, parser):
+        parser.add_argument(
+            "--past-only",
+            action="store_true",
+            help="Skip the summary; just list device types past end-of-service-life.",
+        )
+
+    def handle(self, *args, **options):
+        device_types = DeviceType.objects.select_related("manufacturer").all()
+        counts = Counter()
+        past_rows = []
+
+        for dt in device_types:
+            part = (dt.part_number or "").strip()
+            if not part:
+                counts["no_part_number"] += 1
+                continue
+            rec = lookup_part(part)
+            if not rec:
+                counts["not_found"] += 1
+                continue
+            counts[rec["state"]] += 1
+            if rec["state"] == "risk":
+                past_rows.append((dt, rec))
+
+        total = sum(counts.values())
+
+        if not options.get("past_only"):
+            self.stdout.write(self.style.MIGRATE_HEADING("EOSL.ai audit — {} device types".format(total)))
+            label = {
+                "risk": "Past / action recommended",
+                "watch": "Ending soon (plan/watch)",
+                "clear": "Tracked, supported",
+                "active": "Active — no EOL announced",
+                "not_found": "Not found in EOSL.ai",
+                "no_part_number": "No part number set",
+            }
+            for key in ("risk", "watch", "clear", "active", "not_found", "no_part_number"):
+                if counts.get(key):
+                    self.stdout.write("  {:<32} {}".format(label[key] + ":", counts[key]))
+
+        if past_rows:
+            self.stdout.write("")
+            self.stdout.write(self.style.WARNING("Past end-of-service-life:"))
+            for dt, rec in sorted(past_rows, key=lambda r: r[1].get("eosl") or ""):
+                try:
+                    instances = dt.instances.count()
+                except Exception:
+                    instances = "?"
+                self.stdout.write(
+                    "  {vendor} {model} ({part}) — EOSL {eosl} — {n} in service — {url}".format(
+                        vendor=rec.get("vendor") or (dt.manufacturer and dt.manufacturer.name) or "",
+                        model=dt.model,
+                        part=rec.get("part"),
+                        eosl=rec.get("eosl") or "n/a",
+                        n=instances,
+                        url=rec.get("page_url"),
+                    )
+                )
+        elif not options.get("past_only"):
+            self.stdout.write("")
+            self.stdout.write(self.style.SUCCESS("No device types are past end-of-service-life. 🎉"))

netbox_eosl-0.1.0/netbox_eosl/matching.py

@@ -0,0 +1,93 @@
+"""Pure part-number matching logic — no Django/NetBox imports, so it is unit-testable standalone.
+
+Matching is deterministic and conservative: exact first, then a punctuation/case-insensitive
+"loose" match, then a **vendor-gated** vendor-abbreviation expansion (e.g. Fortinet FG- -> FortiGate-).
+It never does fuzzy/substring matching, and vendor-specific aliases only apply when the NetBox
+manufacturer matches that vendor — so it can't cross-match one vendor's part onto another's record.
+"""
+import re
+
+# Official Fortinet SKU-abbreviation -> product-line prefixes. EOSL.ai stores the long form
+# (e.g. "FortiGate-60E"); NetBox device types commonly use the short SKU form (e.g. "FG-60E").
+FORTINET_PREFIX = {
+    "FG": "FORTIGATE",
+    "FS": "FORTISWITCH",
+    "FAP": "FORTIAP",
+    "FAZ": "FORTIANALYZER",
+    "FMG": "FORTIMANAGER",
+    "FWB": "FORTIWEB",
+    "FAD": "FORTIADC",
+    "FML": "FORTIMAIL",
+    "FPX": "FORTIPROXY",
+    "FEX": "FORTIEXTENDER",
+    "FAC": "FORTIAUTHENTICATOR",
+    "FDD": "FORTIDDOS",
+    "FSA": "FORTISANDBOX",
+}
+
+
+def loose(s):
+    """Uppercase, strip every non-alphanumeric char. 'FortiGate-60E' and 'fortigate 60e' -> 'FORTIGATE60E'."""
+    return re.sub(r"[^A-Z0-9]", "", (s or "").upper())
+
+
+def build_index(skus):
+    """Return (exact, loose_index): UPPER(pid)->rec and loose(pid)->rec. First writer wins on collisions."""
+    exact, loose_index = {}, {}
+    for rec in skus:
+        pid = (rec.get("p") or "").strip().upper()
+        if not pid:
+            continue
+        exact.setdefault(pid, rec)
+        loose_index.setdefault(loose(pid), rec)
+    return exact, loose_index
+
+
+def _is_fortinet(vendor):
+    return bool(vendor) and "FORTINET" in vendor.upper()
+
+
+def candidate_loose_keys(part, vendor=None):
+    """Loose keys to try, most-specific first. Vendor-gated aliases only; deterministic, never fuzzy."""
+    keys, seen = [], set()
+
+    def add(raw):
+        k = loose(raw)
+        if k and k not in seen:
+            seen.add(k)
+            keys.append(k)
+
+    add(part)
+    if _is_fortinet(vendor):
+        lp = loose(part)
+        for ab, full in FORTINET_PREFIX.items():
+            # e.g. 'FG60E'.startswith('FG') -> 'FORTIGATE' + '60E'
+            if lp.startswith(ab) and len(lp) > len(ab) and not lp.startswith(full):
+                add(full + lp[len(ab):])
+    return keys
+
+
+def match(part, vendor, exact, loose_index):
+    """Resolve a part number to a record, or None. Exact -> loose -> vendor-gated alias."""
+    if not part:
+        return None
+    u = part.strip().upper()
+    if u in exact:
+        return exact[u]
+    for k in candidate_loose_keys(part, vendor):
+        rec = loose_index.get(k)
+        if rec:
+            return rec
+    return None
+
+
+def classify(rec):
+    """(state, label, bootstrap_css) from a lookup record. Templates stay logic-free."""
+    if rec.get("a"):
+        return ("active", "Active — no EOL announced", "success")
+    band = rec.get("xb") or ""
+    if band in ("High exposure", "Action recommended"):
+        return ("risk", band, "danger")
+    if band in ("Plan", "Watch"):
+        return ("watch", band, "warning")
+    return ("clear", band or "Tracked", "info")

netbox_eosl-0.1.0/netbox_eosl/template_content.py

@@ -0,0 +1,46 @@
+"""Inject an EOSL.ai lifecycle panel into Device and Device Type detail pages."""
+from netbox.plugins import PluginTemplateExtension
+
+from .client import lookup_part, search_url
+
+_TEMPLATE = "netbox_eosl/eosl_panel.html"
+
+
+def _manufacturer_name(device_type):
+    mfr = getattr(device_type, "manufacturer", None)
+    return getattr(mfr, "name", "") or ""
+
+
+def _panel(extension, part_number, vendor):
+    """Shared renderer for both models."""
+    return extension.render(
+        _TEMPLATE,
+        extra_context={
+            "eosl": lookup_part(part_number, vendor),
+            "queried_part": part_number,
+            "search_url": search_url(part_number),
+        },
+    )
+
+
+class DeviceEOSL(PluginTemplateExtension):
+    models = ["dcim.device"]
+
+    def right_page(self):
+        device = self.context["object"]
+        # A device's ordering PID + manufacturer live on its device type.
+        device_type = getattr(device, "device_type", None)
+        part = getattr(device_type, "part_number", "") or ""
+        return _panel(self, part, _manufacturer_name(device_type))
+
+
+class DeviceTypeEOSL(PluginTemplateExtension):
+    models = ["dcim.devicetype"]
+
+    def right_page(self):
+        device_type = self.context["object"]
+        part = getattr(device_type, "part_number", "") or ""
+        return _panel(self, part, _manufacturer_name(device_type))
+
+
+template_extensions = [DeviceEOSL, DeviceTypeEOSL]

netbox_eosl-0.1.0/netbox_eosl/templates/netbox_eosl/eosl_panel.html

@@ -0,0 +1,57 @@
+{# EOSL.ai lifecycle panel, rendered on the right column of Device and Device Type pages. #}
+<div class="card">
+  <h2 class="card-header">
+    Hardware End-of-Life
+    <a href="https://eosl.ai/" target="_blank" rel="noopener" class="float-end text-muted" title="Data source: EOSL.ai" style="font-size:0.7em;font-weight:400;">EOSL.ai</a>
+  </h2>
+  {% if eosl %}
+    <table class="table table-hover attr-table">
+      <tr>
+        <th scope="row">Status</th>
+        <td><span class="badge text-bg-{{ eosl.state_css }}">{{ eosl.state_label }}</span></td>
+      </tr>
+      <tr>
+        <th scope="row">Part number</th>
+        <td><code>{{ eosl.part }}</code></td>
+      </tr>
+      {% if eosl.end_of_sale %}
+      <tr>
+        <th scope="row">End of sale</th>
+        <td>{{ eosl.end_of_sale }}</td>
+      </tr>
+      {% endif %}
+      <tr>
+        <th scope="row">End of service life</th>
+        <td>{% if eosl.eosl %}{{ eosl.eosl }}{% else %}<span class="text-muted">Not published</span>{% endif %}</td>
+      </tr>
+      {% if eosl.exposure_score is not None %}
+      <tr>
+        <th scope="row">EOSL Exposure Score</th>
+        <td>{{ eosl.exposure_score }}/100 <span class="text-muted">({{ eosl.exposure_band }})</span></td>
+      </tr>
+      {% endif %}
+      {% if eosl.source_url %}
+      <tr>
+        <th scope="row">Vendor bulletin</th>
+        <td><a href="{{ eosl.source_url }}" target="_blank" rel="noopener">Source&nbsp;&raquo;</a></td>
+      </tr>
+      {% endif %}
+    </table>
+    <div class="card-footer text-end">
+      <a href="{{ eosl.page_url }}" target="_blank" rel="noopener" class="btn btn-sm btn-primary">View on EOSL.ai</a>
+    </div>
+  {% elif queried_part %}
+    <div class="card-body">
+      <p class="text-muted mb-2">
+        No exact end-of-life record for part number <code>{{ queried_part }}</code> in the EOSL.ai database.
+      </p>
+      <a href="{{ search_url }}" target="_blank" rel="noopener" class="btn btn-sm btn-outline-secondary">Search EOSL.ai</a>
+    </div>
+  {% else %}
+    <div class="card-body">
+      <p class="text-muted mb-0">
+        Set a <strong>part number</strong> on this device type to check its end-of-life status against EOSL.ai.
+      </p>
+    </div>
+  {% endif %}
+</div>

netbox_eosl-0.1.0/netbox_eosl.egg-info/PKG-INFO

@@ -0,0 +1,145 @@
+Metadata-Version: 2.4
+Name: netbox-eosl
+Version: 0.1.0
+Summary: Show source-backed hardware end-of-service-life status on NetBox Devices and Device Types, from EOSL.ai.
+Author-email: "EOSL.ai" <hello@eosl.ai>
+License: Apache-2.0
+Project-URL: Homepage, https://eosl.ai/
+Project-URL: Data source, https://eosl.ai/api/
+Project-URL: Source, https://github.com/Kranny36/netbox-eosl
+Keywords: netbox,netbox-plugin,eosl,end-of-life,eol,lifecycle,dcim
+Classifier: Framework :: Django
+Classifier: Intended Audience :: System Administrators
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: System :: Networking :: Monitoring
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: requests>=2.25
+Dynamic: license-file
+
+# netbox-eosl
+
+Show **source-backed hardware end-of-service-life (EOSL) status** on your NetBox Devices and
+Device Types, straight from [EOSL.ai](https://eosl.ai) — where every date links to the vendor's
+own end-of-life bulletin.
+
+A panel appears on the right side of each Device and Device Type page: end-of-sale date,
+end-of-service-life date, the EOSL Exposure Score, a link to the vendor bulletin, and a link to
+the full EOSL.ai model page. A `manage.py eosl_check` command audits your whole inventory.
+
+Matching is **exact part-number only** — the plugin never fuzzy-matches, so it can't put a wrong
+end-of-life date on the wrong device. If a part number isn't in the database, it says so and
+offers a search link instead of guessing.
+
+## Requirements
+
+| | |
+|---|---|
+| NetBox | **4.3** or later (uses the `models` template-extension API) |
+| Python | 3.10+ |
+| Network | outbound HTTPS to `eosl.ai` from the NetBox host |
+
+## Install
+
+```bash
+# In your NetBox virtual environment
+source /opt/netbox/venv/bin/activate
+pip install netbox-eosl
+```
+
+Add it to NetBox's `configuration.py`:
+
+```python
+PLUGINS = [
+    "netbox_eosl",
+]
+```
+
+(Optional) tune it:
+
+```python
+PLUGINS_CONFIG = {
+    "netbox_eosl": {
+        "api_url": "https://eosl.ai",   # data source origin
+        "cache_timeout": 86400,          # seconds to cache the lookup table (default 24h)
+        "request_timeout": 5,            # network timeout in seconds
+    },
+}
+```
+
+Then restart NetBox and run migrations (none are added, but this reloads plugins):
+
+```bash
+python /opt/netbox/netbox/manage.py migrate
+sudo systemctl restart netbox netbox-rq
+```
+
+Add `netbox-eosl` to your `local_requirements.txt` so upgrades keep it installed.
+
+## Use
+
+**In the UI** — open any Device or Device Type that has a **part number** set. The
+"Hardware End-of-Life" card appears in the right column.
+
+**Inventory audit** — from the NetBox host:
+
+```bash
+python /opt/netbox/netbox/manage.py eosl_check
+```
+
+```
+EOSL.ai audit — 214 device types
+  Past / action recommended:       57
+  Ending soon (plan/watch):        18
+  Tracked, supported:              44
+  Active — no EOL announced:        9
+  Not found in EOSL.ai:            79
+  No part number set:               7
+
+Past end-of-service-life:
+  Cisco Catalyst 3850-48P (WS-C3850-48P-S) — EOSL 2025-10 — 12 in service — https://eosl.ai/system/cisco-catalyst-3850/
+  ...
+```
+
+Use `--past-only` to print just the past-EOSL list (handy in a cron/report).
+
+## How matching works
+
+The plugin downloads `https://eosl.ai/data/lookup.json` (the same part-number → status map that
+powers the eosl.ai bulk checker) and caches it. For each Device Type it resolves the `part_number`
+field (a Device inherits it from its Device Type) in three deterministic, conservative steps:
+
+1. **Exact** match (case-insensitive).
+2. **Loose** match — ignores spaces/dashes/case, so `FortiGate 60E` resolves `FortiGate-60E`.
+3. **Vendor-gated aliases** — expands a manufacturer's short SKU form to the catalogued long form,
+   but **only when the NetBox manufacturer matches that vendor**. E.g. a Fortinet `FG-60E` resolves
+   `FortiGate-60E`, `FS-148E` → `FortiSwitch-148E`, `FAP-221E` → `FortiAP-221E`. The vendor gate means
+   a non-Fortinet `FG-…` can never be mis-resolved onto a Fortinet record.
+
+There is **no fuzzy or substring matching**. No part number, or no confident match → a neutral
+"not tracked" panel with a search link. Nothing is inferred.
+
+The matching logic lives in `netbox_eosl/matching.py` (no Django imports) and is unit-tested in
+`tests/` — run `python tests/test_matching.py` (or `pytest`).
+
+## Data & trust
+
+- Dates come from EOSL.ai, sourced from each vendor's official end-of-life bulletin and linked
+  for verification. Where a vendor publishes no per-model EOSL date, EOSL.ai computes it from the
+  vendor's published support-life policy and labels it "computed".
+- This plugin **reads** public data; it sends none of your inventory anywhere. The only outbound
+  request is fetching the public lookup table.
+- Confirm any critical date against the linked vendor bulletin before a purchase, renewal, or
+  migration decision.
+
+## License
+
+Apache-2.0. See `LICENSE`.
+
+## Contributing / publishing
+
+Issues and PRs welcome — especially additional vendor SKU aliases (see `FORTINET_PREFIX` in
+`matching.py` for the pattern) and screenshots. Maintainers: see `PUBLISHING.md` for the
+PyPI + NetBox-community release steps.

netbox_eosl-0.1.0/netbox_eosl.egg-info/SOURCES.txt

@@ -0,0 +1,18 @@
+LICENSE
+MANIFEST.in
+README.md
+pyproject.toml
+netbox_eosl/__init__.py
+netbox_eosl/client.py
+netbox_eosl/matching.py
+netbox_eosl/template_content.py
+netbox_eosl.egg-info/PKG-INFO
+netbox_eosl.egg-info/SOURCES.txt
+netbox_eosl.egg-info/dependency_links.txt
+netbox_eosl.egg-info/requires.txt
+netbox_eosl.egg-info/top_level.txt
+netbox_eosl/management/__init__.py
+netbox_eosl/management/commands/__init__.py
+netbox_eosl/management/commands/eosl_check.py
+netbox_eosl/templates/netbox_eosl/eosl_panel.html
+tests/test_matching.py

netbox_eosl-0.1.0/netbox_eosl.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

netbox_eosl-0.1.0/netbox_eosl.egg-info/requires.txt

@@ -0,0 +1 @@
+requests>=2.25

netbox_eosl-0.1.0/netbox_eosl.egg-info/top_level.txt

@@ -0,0 +1 @@
+netbox_eosl

netbox_eosl-0.1.0/pyproject.toml

@@ -0,0 +1,32 @@
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "netbox-eosl"
+version = "0.1.0"
+description = "Show source-backed hardware end-of-service-life status on NetBox Devices and Device Types, from EOSL.ai."
+readme = "README.md"
+requires-python = ">=3.10"
+license = { text = "Apache-2.0" }
+authors = [{ name = "EOSL.ai", email = "hello@eosl.ai" }]
+keywords = ["netbox", "netbox-plugin", "eosl", "end-of-life", "eol", "lifecycle", "dcim"]
+dependencies = ["requests>=2.25"]
+classifiers = [
+    "Framework :: Django",
+    "Intended Audience :: System Administrators",
+    "License :: OSI Approved :: Apache Software License",
+    "Programming Language :: Python :: 3",
+    "Topic :: System :: Networking :: Monitoring",
+]
+
+[project.urls]
+Homepage = "https://eosl.ai/"
+"Data source" = "https://eosl.ai/api/"
+Source = "https://github.com/Kranny36/netbox-eosl"
+
+[tool.setuptools.packages.find]
+include = ["netbox_eosl*"]
+
+[tool.setuptools.package-data]
+netbox_eosl = ["templates/netbox_eosl/*.html"]

netbox_eosl-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

netbox_eosl-0.1.0/tests/test_matching.py

@@ -0,0 +1,75 @@
+"""Unit tests for the pure matching logic. Runnable without NetBox/Django:  python -m pytest  (or the
+plain-python fallback at the bottom:  python tests/test_matching.py)."""
+import importlib.util
+import os
+import sys
+
+# Load matching.py directly by path so we don't trigger netbox_eosl/__init__.py (which imports NetBox).
+_MATCHING = os.path.join(os.path.dirname(__file__), "..", "netbox_eosl", "matching.py")
+_spec = importlib.util.spec_from_file_location("netbox_eosl_matching", _MATCHING)
+matching = importlib.util.module_from_spec(_spec)
+_spec.loader.exec_module(matching)
+
+# A tiny fixture mirroring the shape of eosl.ai's lookup.json "skus" records.
+SKUS = [
+    {"p": "WS-C3850-48P-S", "v": "Cisco", "f": "Catalyst 3850 Series", "s": "cisco-catalyst-3850",
+     "eos": "2020-10", "eol": "2025-10", "xb": "High exposure", "xs": 23, "a": 0},
+    {"p": "FortiGate-60E", "v": "Fortinet", "f": "FortiGate 60E", "s": "fortinet-fortigate-60e",
+     "eos": "2023-06", "eol": "2028-06", "xb": "Plan", "xs": 60, "a": 0},
+    {"p": "FortiSwitch-124E", "v": "Fortinet", "f": "FortiSwitch 124E", "s": "fortinet-fortiswitch-124e",
+     "eos": "2024-01", "eol": "2029-01", "xb": "Watch", "xs": 75, "a": 0},
+    {"p": "J9856A", "v": "HPE", "f": "Aruba 2530", "s": "hpe-aruba-2530", "eol": "2027-01",
+     "xb": "Action recommended", "xs": 45, "a": 0},
+    {"p": "PA-220", "v": "Palo Alto Networks", "f": "PA-220", "s": "palo-alto-pa-220", "a": 1, "xb": "Current"},
+]
+
+
+def _idx():
+    return matching.build_index(SKUS)
+
+
+def check(part, vendor, expected_pid):
+    exact, loose = _idx()
+    rec = matching.match(part, vendor, exact, loose)
+    got = rec["p"] if rec else None
+    status = "ok " if got == expected_pid else "FAIL"
+    print(f"  [{status}] match({part!r}, {vendor!r}) -> {got!r} (expected {expected_pid!r})")
+    return got == expected_pid
+
+
+def run():
+    print("matching tests:")
+    ok = True
+    # Exact matches (any case / punctuation)
+    ok &= check("WS-C3850-48P-S", "Cisco", "WS-C3850-48P-S")
+    ok &= check("ws-c3850-48p-s", "Cisco", "WS-C3850-48P-S")
+    ok &= check("WS C3850 48P S", "Cisco", "WS-C3850-48P-S")          # loose (spaces)
+    # Fortinet short SKU -> long form, vendor-gated
+    ok &= check("FG-60E", "Fortinet", "FortiGate-60E")
+    ok &= check("fg-60e", "Fortinet", "FortiGate-60E")
+    ok &= check("FortiGate 60E", "Fortinet", "FortiGate-60E")
+    ok &= check("FS-124E", "Fortinet", "FortiSwitch-124E")
+    # HPE J-number exact
+    ok &= check("J9856A", "HPE", "J9856A")
+    # Active/noEol product still resolves
+    ok &= check("PA-220", "Palo Alto Networks", "PA-220")
+    # Safety: the FG- alias must NOT fire for a non-Fortinet vendor (no cross-match)
+    ok &= check("FG-60E", "Acme", None)
+    ok &= check("FG-60E", None, None)
+    # Unknown part -> None
+    ok &= check("DOES-NOT-EXIST", "Cisco", None)
+    # classify sanity
+    assert matching.classify(SKUS[0])[0] == "risk"
+    assert matching.classify(SKUS[4])[0] == "active"
+    print("classify: ok")
+    print("ALL PASS" if ok else "SOME FAILED")
+    return ok
+
+
+# pytest entrypoints
+def test_matching():
+    assert run()
+
+
+if __name__ == "__main__":
+    sys.exit(0 if run() else 1)