OK, that should be all the new packaging support files. Currently the dependencies are based on local files, but once we test each for individual the installs locally and make sure the tests work properly, we can then publish

the core and adjust the model/codegen/meta package requirements so they refer to the content on PyPI.

Author: haxsaw

README-codegen.rst

@@ -0,0 +1,59 @@
+
+.. |travis| image:: https://travis-ci.com/haxsaw/hikaru.svg?branch=dev
+    :target: https://app.travis-ci.com/github/haxsaw/hikaru
+
+.. |license| image:: https://img.shields.io/github/license/haxsaw/hikaru
+   :alt: GitHub license   :target: https://github.com/haxsaw/hikaru/blob/main/LICENSE
+
+.. |versions| image:: https://img.shields.io/pypi/pyversions/hikaru
+   :alt: PyPI - Python Version
+
+.. |coverage| image:: https://codecov.io/gh/haxsaw/hikaru/branch/dev/graph/badge.svg?token=QOFGNVHGNP
+   :target: https://codecov.io/gh/haxsaw/hikaru
+   
+.. |logo| image:: hikaru-model-26-logo.png
+   :alt: Hikaru
+
+|logo|
+
+
+Version 1.1.0
+
+|travis|   |license|   |versions|   |coverage|
+
+`Try it: see Hikaru convert your K8s YAML <http://www.incisivetech.co.uk/try-hikaru.html>`_
+
+`Release notes <https://github.com/haxsaw/hikaru/blob/main/release_notes.rst>`_
+
+`Full documentation at Read the Docs <https://hikaru.readthedocs.io/en/latest/index.html>`_
+
+Hikaru is a collection of tools that allow you to work with Kubernetes resources from within Python in
+a variety of ways:
+
+- Hikaru provides type-annotated classes that model all of the Kubernetes resources in Python
+  and supports CRUD operations on those classes to manage their lifecycle in your Kubernetes cluster.
+- Hikaru also provides tooling to shift formats for these objects, allowing you to turn K8s YAML
+  into Python objects, JSON, or Python dicts, and vice-versa. It can also generate Python source code for K8s
+  objects loaded from non-Python sources.
+- Hikaru also supports a number of features that aid in the management of
+  your objects such as searching for specific fields or diffing two instances of a K8s resource.
+- Hikaru includes support for creating 'watches' on your objects, providing a means to monitor events
+  on your provisioned K8s resources.
+- Hikaru provides support for creation of CRDs which support all the above features such as CRUD operations
+  and watches.
+- Finally, Hikaru includes a facility to specify a collection of
+  resources as an 'application', similar in spirit to a Helm chart, and provides the same CRUD,
+  watch, and management capabilities on the entire application as it does on single resource objects
+  (full format shifting support to come).
+
+**This package supports resources from the Kubernetes Python client version 26.x**. It depends on the
+``hikaru-core`` package which will be installed automatically when this packages is installed. This package
+will work with any version of the Kubernetes Python client >= 26.x; if you need to constrain which release
+is installed then you should establish your own requirement limts on the Kubernetes Python client package.
+
+See README-core.rst for the main README and links to overall documentation.
+
+About
+~~~~~
+
+Hikaru is Mr. Sulu’s first name, a famed fictional helmsman.

README-core.rst

@@ -27,33 +27,33 @@ Version 1.1.0
 
 `Full documentation at Read the Docs <https://hikaru.readthedocs.io/en/latest/index.html>`_
 
-``Hikaru`` is a collection of tools that allow you to work with Kubernetes resources from within Python in
+Hikaru is a collection of tools that allow you to work with Kubernetes resources from within Python in
 a variety of ways:
 
-- ``Hikaru`` provides type-annotated classes that model all of the Kubernetes resources in Python
+- Hikaru provides type-annotated classes that model all of the Kubernetes resources in Python
   and supports CRUD operations on those classes to manage their lifecycle in your Kubernetes cluster.
-- ``Hikaru`` also provides tooling to shift formats for these objects, allowing you to turn K8s YAML
+- Hikaru also provides tooling to shift formats for these objects, allowing you to turn K8s YAML
   into Python objects, JSON, or Python dicts, and vice-versa. It can also generate Python source code for K8s
   objects loaded from non-Python sources.
-- ``Hikaru`` also supports a number of features that aid in the management of
+- Hikaru also supports a number of features that aid in the management of
   your objects such as searching for specific fields or diffing two instances of a K8s resource.
-- ``Hikaru`` includes support for creating 'watches' on your objects, providing a means to monitor events
+- Hikaru includes support for creating 'watches' on your objects, providing a means to monitor events
   on your provisioned K8s resources.
-- ``Hikaru`` provides support for creation of CRDs which support all the above features such as CRUD operations
+- Hikaru provides support for creation of CRDs which support all the above features such as CRUD operations
   and watches.
-- Finally, ``Hikaru`` includes a facility to specify a collection of
+- Finally, Hikaru includes a facility to specify a collection of
   resources as an 'application', similar in spirit to a Helm chart, and provides the same CRUD,
   watch, and management capabilities on the entire application as it does on single resource objects
   (full format shifting support to come).
 
 The ``hikaru-core`` package provides all the base machinery to support the above capabilities but
 does not include any of the Kubernetes model objects, nor does it include the support to generate
-Python source code from in-memory ``hikaru`` objects.
+Python source code from in-memory Hikaru objects.
 
 - For model objects, install one of the ``hikaru-model-*`` packages. The ``hikaru-core`` package is
   is a requirement for all model packages, so you will automatically get ``hikaru-core`` when you
   install a model. You may install as many model releases into the same Python instance as you wish, but
-  you will need to indicate to ``hikaru`` which release should be used when create objects from a
+  you will need to indicate to Hikaru which release should be used when create objects from a
   cluster or other sources.
 - For source code generation capabilities, you'll need to install the ``hikaru-codegen`` package.
 
@@ -135,10 +135,10 @@ you to build your own controllers for your CRDs.
 Model entire applications
 -------------------------
 
-``Hikaru`` provides an application base class that can be derived from to allow the creation
-of sets of resources that comprise the infra for an application system. This application model
+Hikaru provides an Application base class that can be derived from to allow the creation
+of sets of resources that comprise the infra for an application system. This Application model
 can be inspected, provisioned into a cluster, read from a cluster, and watched, just like
-with individual ``hikaru`` K8s objects.
+with individual Hikaru K8s objects.
 
 Integrate your own subclasses
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

README-model-23.rst

@@ -27,29 +27,29 @@ Version 1.1.0
 
 `Full documentation at Read the Docs <https://hikaru.readthedocs.io/en/latest/index.html>`_
 
-``Hikaru`` is a collection of tools that allow you to work with Kubernetes resources from within Python in
+Hikaru is a collection of tools that allow you to work with Kubernetes resources from within Python in
 a variety of ways:
 
-- ``Hikaru`` provides type-annotated classes that model all of the Kubernetes resources in Python
+- Hikaru provides type-annotated classes that model all of the Kubernetes resources in Python
   and supports CRUD operations on those classes to manage their lifecycle in your Kubernetes cluster.
-- ``Hikaru`` also provides tooling to shift formats for these objects, allowing you to turn K8s YAML
+- Hikaru also provides tooling to shift formats for these objects, allowing you to turn K8s YAML
   into Python objects, JSON, or Python dicts, and vice-versa. It can also generate Python source code for K8s
   objects loaded from non-Python sources.
-- ``Hikaru`` also supports a number of features that aid in the management of
+- Hikaru also supports a number of features that aid in the management of
   your objects such as searching for specific fields or diffing two instances of a K8s resource.
-- ``Hikaru`` includes support for creating 'watches' on your objects, providing a means to monitor events
+- Hikaru includes support for creating 'watches' on your objects, providing a means to monitor events
   on your provisioned K8s resources.
-- ``Hikaru`` provides support for creation of CRDs which support all the above features such as CRUD operations
+- Hikaru provides support for creation of CRDs which support all the above features such as CRUD operations
   and watches.
-- Finally, ``Hikaru`` includes a facility to specify a collection of
+- Finally, Hikaru includes a facility to specify a collection of
   resources as an 'application', similar in spirit to a Helm chart, and provides the same CRUD,
   watch, and management capabilities on the entire application as it does on single resource objects
   (full format shifting support to come).
 
 **This package supports resources from the Kubernetes Python client version 23.x**. It depends on the
 ``hikaru-core`` package which will be installed automatically when this packages is installed. This package
 will work with any version of the Kubernetes Python client >= 23.x; if you need to constrain which release
-is installed then you should establish your own requirement limts on the Kubernetes Python client package.
+is installed then you should establish your own requirement limits on the Kubernetes Python client package.
 
 See README-core.rst for the main README and links to overall documentation.
 

README-model-24.rst

@@ -27,21 +27,21 @@ Version 1.1.0
 
 `Full documentation at Read the Docs <https://hikaru.readthedocs.io/en/latest/index.html>`_
 
-``Hikaru`` is a collection of tools that allow you to work with Kubernetes resources from within Python in
+Hikaru is a collection of tools that allow you to work with Kubernetes resources from within Python in
 a variety of ways:
 
-- ``Hikaru`` provides type-annotated classes that model all of the Kubernetes resources in Python
+- Hikaru provides type-annotated classes that model all of the Kubernetes resources in Python
   and supports CRUD operations on those classes to manage their lifecycle in your Kubernetes cluster.
-- ``Hikaru`` also provides tooling to shift formats for these objects, allowing you to turn K8s YAML
+- Hikaru also provides tooling to shift formats for these objects, allowing you to turn K8s YAML
   into Python objects, JSON, or Python dicts, and vice-versa. It can also generate Python source code for K8s
   objects loaded from non-Python sources.
-- ``Hikaru`` also supports a number of features that aid in the management of
+- Hikaru also supports a number of features that aid in the management of
   your objects such as searching for specific fields or diffing two instances of a K8s resource.
-- ``Hikaru`` includes support for creating 'watches' on your objects, providing a means to monitor events
+- Hikaru includes support for creating 'watches' on your objects, providing a means to monitor events
   on your provisioned K8s resources.
-- ``Hikaru`` provides support for creation of CRDs which support all the above features such as CRUD operations
+- Hikaru provides support for creation of CRDs which support all the above features such as CRUD operations
   and watches.
-- Finally, ``Hikaru`` includes a facility to specify a collection of
+- Finally, Hikaru includes a facility to specify a collection of
   resources as an 'application', similar in spirit to a Helm chart, and provides the same CRUD,
   watch, and management capabilities on the entire application as it does on single resource objects
   (full format shifting support to come).

README-model-25.rst

@@ -27,21 +27,21 @@ Version 1.1.0
 
 `Full documentation at Read the Docs <https://hikaru.readthedocs.io/en/latest/index.html>`_
 
-``Hikaru`` is a collection of tools that allow you to work with Kubernetes resources from within Python in
+Hikaru is a collection of tools that allow you to work with Kubernetes resources from within Python in
 a variety of ways:
 
-- ``Hikaru`` provides type-annotated classes that model all of the Kubernetes resources in Python
+- Hikaru provides type-annotated classes that model all of the Kubernetes resources in Python
   and supports CRUD operations on those classes to manage their lifecycle in your Kubernetes cluster.
-- ``Hikaru`` also provides tooling to shift formats for these objects, allowing you to turn K8s YAML
+- Hikaru also provides tooling to shift formats for these objects, allowing you to turn K8s YAML
   into Python objects, JSON, or Python dicts, and vice-versa. It can also generate Python source code for K8s
   objects loaded from non-Python sources.
-- ``Hikaru`` also supports a number of features that aid in the management of
+- Hikaru also supports a number of features that aid in the management of
   your objects such as searching for specific fields or diffing two instances of a K8s resource.
-- ``Hikaru`` includes support for creating 'watches' on your objects, providing a means to monitor events
+- Hikaru includes support for creating 'watches' on your objects, providing a means to monitor events
   on your provisioned K8s resources.
-- ``Hikaru`` provides support for creation of CRDs which support all the above features such as CRUD operations
+- Hikaru provides support for creation of CRDs which support all the above features such as CRUD operations
   and watches.
-- Finally, ``Hikaru`` includes a facility to specify a collection of
+- Finally, Hikaru includes a facility to specify a collection of
   resources as an 'application', similar in spirit to a Helm chart, and provides the same CRUD,
   watch, and management capabilities on the entire application as it does on single resource objects
   (full format shifting support to come).

README-model-26.rst

@@ -27,21 +27,21 @@ Version 1.1.0
 
 `Full documentation at Read the Docs <https://hikaru.readthedocs.io/en/latest/index.html>`_
 
-``Hikaru`` is a collection of tools that allow you to work with Kubernetes resources from within Python in
+Hikaru is a collection of tools that allow you to work with Kubernetes resources from within Python in
 a variety of ways:
 
-- ``Hikaru`` provides type-annotated classes that model all of the Kubernetes resources in Python
+- Hikaru provides type-annotated classes that model all of the Kubernetes resources in Python
   and supports CRUD operations on those classes to manage their lifecycle in your Kubernetes cluster.
-- ``Hikaru`` also provides tooling to shift formats for these objects, allowing you to turn K8s YAML
+- Hikaru also provides tooling to shift formats for these objects, allowing you to turn K8s YAML
   into Python objects, JSON, or Python dicts, and vice-versa. It can also generate Python source code for K8s
   objects loaded from non-Python sources.
-- ``Hikaru`` also supports a number of features that aid in the management of
+- Hikaru also supports a number of features that aid in the management of
   your objects such as searching for specific fields or diffing two instances of a K8s resource.
-- ``Hikaru`` includes support for creating 'watches' on your objects, providing a means to monitor events
+- Hikaru includes support for creating 'watches' on your objects, providing a means to monitor events
   on your provisioned K8s resources.
-- ``Hikaru`` provides support for creation of CRDs which support all the above features such as CRUD operations
+- Hikaru provides support for creation of CRDs which support all the above features such as CRUD operations
   and watches.
-- Finally, ``Hikaru`` includes a facility to specify a collection of
+- Finally, Hikaru includes a facility to specify a collection of
   resources as an 'application', similar in spirit to a Helm chart, and provides the same CRUD,
   watch, and management capabilities on the entire application as it does on single resource objects
   (full format shifting support to come).

README.rst

@@ -17,7 +17,7 @@
 |logo|
 
 
-Version 1.0.1
+Version 1.1.0
 
 |travis|   |license|   |versions|   |coverage|
 
@@ -27,15 +27,41 @@ Version 1.0.1
 
 `Full documentation at Read the Docs <https://hikaru.readthedocs.io/en/latest/index.html>`_
 
-Hikaru is a tool that provides you the ability to easily shift between
-YAML, Python objects/source, and JSON representations of your Kubernetes config
-files. It provides assistance in authoring these files in Python,
-opens up options in how you can assemble and customise the files, and 
-provides some programmatic tools for inspecting large, complex files to
-enable automation of policy and security compliance.
-
-Additionally, Hikaru allows you to use its K8s model objects to interact with Kubernetes,
-directing it to create, modify, and delete resources.
+Hikaru is a collection of tools that allow you to work with Kubernetes resources from within Python in
+a variety of ways:
+
+- Hikaru provides type-annotated classes that model all of the Kubernetes resources in Python
+  and supports CRUD operations on those classes to manage their lifecycle in your Kubernetes cluster.
+- Hikaru also provides tooling to shift formats for these objects, allowing you to turn K8s YAML
+  into Python objects, JSON, or Python dicts, and vice-versa. It can also generate Python source code for K8s
+  objects loaded from non-Python sources.
+- Hikaru also supports a number of features that aid in the management of
+  your objects such as searching for specific fields or diffing two instances of a K8s resource.
+- Hikaru includes support for creating 'watches' on your objects, providing a means to monitor events
+  on your provisioned K8s resources.
+- Hikaru provides support for creation of CRDs which support all the above features such as CRUD operations
+  and watches.
+- Finally, Hikaru includes a facility to specify a collection of
+  resources as an 'application', similar in spirit to a Helm chart, and provides the same CRUD,
+  watch, and management capabilities on the entire application as it does on single resource objects
+  (full format shifting support to come).
+
+This ``hikaru`` package is a meta-package that has as dependencies:
+
+- ``hikaru-core`` for core Hikaru capabilities
+- ``hikaru-codegen`` for generating formatted Python source from Hikaru objects
+- The four most recent ``hikaru-model-*`` packages, currently:
+
+  - 23.x
+  - 24.x
+  - 25.x
+  - 26.x
+
+See each package's specific PyPI page for any details on that package.
+
+While you can continue to use this meta-package as before, we suggest you migrate to using the model
+versions that match the version of the Kubernetes API you need to interact with. This package just helps
+make that smoother.
 
 From Python
 ~~~~~~~~~~~
@@ -105,6 +131,14 @@ of Hikaru. Automatically generate schema from a Hikaru class, define CRDs to
 Kubernetes, manage CRD instances with CRUD methods, and create watchers that allow
 you to build your own controllers for your CRDs.
 
+Model entire applications
+-------------------------
+
+Hikaru provides an Application base class that can be derived from to allow the creation
+of sets of resources that comprise the infra for an application system. This Application model
+can be inspected, provisioned into a cluster, read from a cluster, and watched, just like
+with individual Hikaru K8s objects.
+
 Integrate your own subclasses
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
@@ -140,7 +174,7 @@ API coverage
 ~~~~~~~~~~~~
 
 Hikaru supports all objects in the OpenAPI swagger spec for
-the Kubernetes API **v 1.16**, and has initial support for methods on those objects
+the Kubernetes API **v 1.26**, and has initial support for methods on those objects
 from the same swagger spec. Additionally, it defines some higher-level CRUD-style
 methods on top of these foundation methods.
 

devdoc/notes.txt

@@ -82,6 +82,10 @@ Other build tasks
 
 Building
 --------
+FIRST, delete any artifacts of previous builds!!!
+
+    rm -rf build
+
 building the package: python setup.py bdist_wheel
 
 Build testing process