cloudcoil 0.2.2__tar.gz → 0.3.0__tar.gz

cloudcoil-0.3.0/.github/workflows/pypi_publish.yml

@@ -0,0 +1,47 @@
+---
+    name: PyPI publish
+    
+    on:
+      release:
+        types: [released]
+    
+    jobs:
+      build:
+        runs-on: ubuntu-latest
+        permissions:
+            # IMPORTANT: this permission is mandatory for Trusted Publishing
+            id-token: write
+        steps:
+          - name: Checkout code
+            uses: actions/checkout@v3
+    
+          - name: Setup Python
+            uses: actions/setup-python@v4
+            with:
+              python-version: "3.10"
+    
+          - name: Install uv
+            uses: astral-sh/setup-uv@v4
+            with:
+              python-version: "3.10"
+              enable-cache: true
+              cache-dependency-glob: "**/uv.lock"
+    
+          - name: Install dependencies
+            run: uv sync --extra all --dev
+    
+          - name: Bump version number
+            run: |
+              sed -i "s/version = \".*\"/version = \"${{ github.event.release.tag_name }}\"/" pyproject.toml
+    
+          - name: Build package
+            run: uv build
+    
+          - name: Publish package distributions to PyPI
+            uses: pypa/gh-action-pypi-publish@release/v1
+          
+          # Trigger a workflow dispatch in the same repository
+          - name: Trigger update-repos workflow
+            uses: peter-evans/repository-dispatch@v1
+            with:
+              event-type: update-repos

cloudcoil-0.3.0/.github/workflows/update_repos.yml

@@ -0,0 +1,30 @@
+
+name: Update Versions
+
+on:
+  push:
+    branches:
+      - main
+  repository_dispatch:
+    types: [update-repos]
+jobs:
+  update-repos:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          token: ${{ secrets.CI_GITHUB_TOKEN }}
+
+      - name: Install uv and set python
+        uses: astral-sh/setup-uv@v4
+        with:
+          python-version: '3.10'
+          enable-cache: true
+          cache-dependency-glob: "**/uv.lock"
+
+      - name: Update all repos
+        env:
+          GITHUB_TOKEN: ${{ secrets.CI_GITHUB_TOKEN }}
+        run: |
+          gh auth setup-git
+          make -j8 publish-all-repos

cloudcoil-0.3.0/.gitignore

@@ -0,0 +1,178 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# UV
+#   Similar to Pipfile.lock, it is generally recommended to include uv.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#uv.lock
+
+# poetry
+#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
+#poetry.lock
+
+# pdm
+#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
+#pdm.lock
+#   pdm stores project-wide configurations in .pdm.toml, but it is recommended to not include it
+#   in version control.
+#   https://pdm.fming.dev/latest/usage/project/#working-with-version-control
+.pdm.toml
+.pdm-python
+.pdm-build/
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+.*cache
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# PyCharm
+#  JetBrains specific template is maintained in a separate JetBrains.gitignore that can
+#  be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
+#  and can be added to the global gitignore or merged into this file.  For a more nuclear
+#  option (not recommended) you can uncomment the following to ignore the entire idea folder.
+#.idea/
+
+# PyPI configuration file
+.pypirc
+processed_swagger.json
+extra_data.json
+.DS_Store
+.vscode
+junit.xml
+/output
+/tmp

cloudcoil-0.3.0/Makefile

@@ -0,0 +1,74 @@
+.PHONY: test
+test:
+	uv run --frozen pytest
+
+.PHONY: lint
+lint:
+	uv run --frozen ruff check cloudcoil tests
+	uv run --frozen ruff format --check cloudcoil tests
+	uv run --frozen mypy -p cloudcoil
+
+.PHONY: fix-lint
+fix-lint:
+	uv run --frozen ruff format cloudcoil tests
+	uv run --frozen ruff check --fix --unsafe-fixes cloudcoil tests
+
+.PHONY: docs-deploy
+docs-deploy:
+	rm -rf docs/index.md
+	cp README.md docs/index.md
+	uv run --frozen mkdocs gh-deploy --force
+
+.PHONY: docs-serve
+docs-serve:
+	rm -rf docs/index.md
+	cp README.md docs/index.md
+	uv run --frozen mkdocs serve
+
+.PHONY: prepare-for-pr
+prepare-for-pr: fix-lint lint test
+	@echo "========"
+	@echo "It looks good! :)"
+	@echo "Make sure to commit all changes!"
+	@echo "========"
+
+.PHONY: gen-models
+gen-models:
+	rm -rf cloudcoil/apimachinery.py
+	uv run --frozen cloudcoil-model-codegen
+	$(MAKE) fix-lint
+
+
+REPOS := $(shell ls models | sed 's/\/$$//')
+
+gen-all-repos: $(addprefix gen-repo-,$(REPOS))
+
+publish-all-repos: $(addprefix publish-repo-,$(REPOS))
+
+gen-repo-%:
+	rm -rf output/models-$*
+	uvx cookiecutter --no-input --output-dir=output --config-file=models/$*/cookiecutter.yaml cookiecutter _config_dir=$$PWD/models/$*
+
+# publish-repo-% creates a repo in cloudcoil/models-$* if it doesn't exist, and pushes the generated code to it
+# It should not force push to the repo and instead change all the existing files in the repo to match the generated code
+# Check if the repo exists using gh
+# If it doesn't exist, create it
+# If it does exist, change all the existing files in the repo to match the generated code
+# Push the generated code to the repo
+publish-repo-%: gen-repo-%
+	@echo "Publishing to cloudcoil/models-$*"
+	@if ! gh repo view cloudcoil/models-$* >/dev/null 2>&1; then \
+		gh repo create cloudcoil/models-$* --public --description "Generated model repository for $*"; \
+	fi
+	@rm -rf tmp/models-$*
+	@mkdir -p tmp/models-$*
+	@cd tmp/models-$* && \
+		git clone https://github.com/cloudcoil/models-$*.git . || git init && \
+		git remote add origin https://github.com/cloudcoil/models-$*.git || true && \
+		git rm -rf . && \
+		git config user.name "github-actions[bot]" && \
+		git config user.email "github-actions[bot]@users.noreply.github.com" && \
+		cp -a ../../output/models-$*/. . && \
+		git add -A && \
+		git diff --cached --quiet || git commit -m "Update generated code" && \
+		git push -u origin HEAD:main

{cloudcoil-0.2.2 → cloudcoil-0.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cloudcoil
-Version: 0.2.2
+Version: 0.3.0
 Summary: Cloud native made easy with Python
 Project-URL: Homepage, https://github.com/cloudcoil/cloudcoil
 Project-URL: Documentation, https://cloudcoil.github.io/cloudcoil
@@ -53,7 +53,7 @@ Description-Content-Type: text/markdown
 
 ## ✨ Features
 
-- 🔥 **Elegant, Pythonic API** - Feels natural to Python developers
+- 🔥 **Elegant, Pythonic API** - Feels natural to Python developers including fluent and context manager style resource builders
 - ⚡ **Async First** - Native async/await support for high performance
 - 🛡️ **Type Safe** - Full mypy support and runtime validation
 - 🧪 **Testing Ready** - Built-in pytest fixtures for K8s integration tests
@@ -114,6 +114,246 @@ for pod in k8s.core.v1.Pod.list(namespace="default"):
 async for pod in await k8s.core.v1.Pod.async_list():
     print(f"Found pod: {pod.metadata.name}")
 ```
+### Building resources
+
+#### Using Models
+
+```python
+from cloudcoil import apimachinery
+import cloudcoil.models.kubernetes.core.v1 as k8score
+import cloudcoil.models.kubernetes.apps.v1 as k8sapps
+
+# Create a Deployment
+deployment = k8sapps.Deployment(
+    metadata=apimachinery.ObjectMeta(name="nginx"),
+    spec=k8sapps.DeploymentSpec(
+        replicas=3,
+        selector=apimachinery.LabelSelector(
+            match_labels={"app": "nginx"}
+        ),
+        template=k8score.PodTemplateSpec(
+            metadata=apimachinery.ObjectMeta(
+                labels={"app": "nginx"}
+            ),
+            spec=k8score.PodSpec(
+                containers=[
+                    k8score.Container(
+                        name="nginx",
+                        image="nginx:latest",
+                        ports=[k8score.ContainerPort(container_port=80)]
+                    )
+                ]
+            )
+        )
+    )
+).create()
+
+# Create a Service
+service = k8score.Service(
+    metadata=apimachinery.ObjectMeta(name="nginx"),
+    spec=k8score.ServiceSpec(
+        selector={"app": "nginx"},
+        ports=[k8score.ServicePort(port=80, target_port=80)]
+    )
+).create()
+
+# List Deployments
+for deploy in k8sapps.Deployment.list():
+    print(f"Found deployment: {deploy.metadata.name}")
+
+# Update a Deployment
+deployment.spec.replicas = 5
+deployment.save()
+
+# Delete resources
+k8score.Service.delete("nginx")
+k8sapps.Deployment.delete("nginx")
+```
+
+#### Using the Fluent Builder API
+
+Cloudcoil provides a powerful fluent builder API for Kubernetes resources with full IDE support and rich autocomplete capabilities:
+
+```python
+from cloudcoil.models.kubernetes.apps.v1 import Deployment
+from cloudcoil.models.kubernetes.core.v1 import Service
+
+# Create a Deployment using the fluent builder
+# The fluent style is great for one-liners and simple configurations
+nginx_deployment = (
+    Deployment.builder()
+    # Metadata can be configured in a single chain for simple objects
+    .metadata(lambda metadata: metadata
+        .name("nginx")
+        .namespace("default")
+    )
+    # Complex nested structures can be built using nested lambda functions
+    .spec(lambda deployment_spec: deployment_spec
+        .replicas(3)
+        # Each level of nesting gets its own lambda for clarity
+        .selector(lambda label_selector: label_selector
+            .match_labels({"app": "nginx"})
+        )
+        .template(lambda pod_template: pod_template
+            .metadata(lambda pod_metadata: pod_metadata
+                .labels({"app": "nginx"})
+            )
+            .spec(lambda pod_spec: pod_spec
+                # Lists can be built using array literals with lambda items
+                .containers([
+                    lambda container: container
+                    .name("nginx")
+                    .image("nginx:latest")
+                    # Nested collections can use the add() helper
+                    .ports(lambda port_list: port_list.add(
+                        lambda port: port.container_port(80)
+                    ))
+                ])
+            )
+        )
+    )
+    .build()
+)
+
+# Create a Service using the builder
+service = (
+    Service.builder()
+    .metadata(lambda m: m
+        .name("nginx")
+        .namespace("default")
+    )
+    .spec(lambda s: s
+        .selector({"app": "nginx"})
+        .ports(lambda ports: ports.add(lambda p: p.container_port(80)))
+    )
+    .build()
+)
+```
+
+The fluent builder provides:
+- ✨ Full IDE support with detailed type information
+- 🔍 Rich autocomplete for all fields and nested objects
+- ⚡ Compile-time validation of your configuration
+- 🎯 Clear and chainable API that guides you through resource creation
+
+#### Using the Context Manager Builder API
+
+For complex nested resources, Cloudcoil also provides a context manager-based builder pattern that can make the structure more clear:
+
+```python
+from cloudcoil.models.kubernetes.apps.v1 import Deployment
+from cloudcoil.models.kubernetes.core.v1 import Service
+
+# Create a deployment using context managers
+# Context managers are ideal for deeply nested structures
+with Deployment.new() as nginx_deployment:
+    # Each context creates a clear visual scope
+    with nginx_deployment.metadata() as deployment_metadata:
+        deployment_metadata.name("nginx")
+        deployment_metadata.namespace("default")
+    
+    with nginx_deployment.spec() as deployment_spec:
+        # Simple fields can be set directly
+        deployment_spec.replicas(3)
+        
+        # Each nested object gets its own context
+        with deployment_spec.selector() as label_selector:
+            label_selector.match_labels({"app": "nginx"})
+        
+        with deployment_spec.template() as pod_template:
+            with pod_template.metadata() as pod_metadata:
+                pod_metadata.labels({"app": "nginx"})
+            
+            with pod_template.spec() as pod_spec:
+                # Collections use a parent context for the list
+                with pod_spec.containers() as container_list:
+                    # And child contexts for each item
+                    with container_list.add() as nginx_container:
+                        nginx_container.name("nginx")
+                        nginx_container.image("nginx:latest")
+                        # Ports can be added one by one
+                        with nginx_container.add_port() as container_port:
+                            container_port.container_port(80)
+
+final_deployment = nginx_deployment.build()
+
+# Create a service using context managers
+with Service.new() as nginx_service:
+    # Context managers make the structure very clear
+    with nginx_service.metadata() as service_metadata:
+        service_metadata.name("nginx")
+        service_metadata.namespace("default")
+    
+    with nginx_service.spec() as service_spec:
+        # Simple fields can still be set directly
+        service_spec.selector({"app": "nginx"})
+        # Port configuration is more readable with contexts
+        with service_spec.add_port() as service_port:
+            service_port.port(80)
+            service_port.target_port(80)
+
+final_service = nginx_service.build()
+```
+
+The context manager builder provides:
+- 🎭 Clear visual nesting of resource structure
+- 🔒 Automatic resource cleanup
+- 🎯 Familiar Python context manager pattern
+- ✨ Same great IDE support as the fluent builder
+
+#### Mixing Builder Styles
+
+CloudCoil's intelligent builder system automatically detects which style you're using and provides appropriate IDE support:
+
+```python
+from cloudcoil.models.kubernetes.apps.v1 import Deployment
+from cloudcoil import apimachinery
+
+# Mixing styles lets you choose the best approach for each part
+# The IDE automatically adapts to your chosen style at each level
+with Deployment.new() as nginx_deployment:
+    # Direct object initialization with full type checking
+    nginx_deployment.metadata(apimachinery.ObjectMeta(
+        name="nginx",
+        namespace="default",
+        labels={"app": "nginx"}
+    ))
+    
+    with nginx_deployment.spec() as deployment_spec:
+        # IDE shows all available fields with types
+        deployment_spec.replicas(3)
+        # Fluent style with rich autocomplete
+        deployment_spec.selector(lambda sel: sel.match_labels({"app": "nginx"}))
+        
+        # Context manager style with full type hints
+        with deployment_spec.template() as pod_template:
+            # Mix and match freely - IDE adjusts automatically
+            pod_template.metadata(apimachinery.ObjectMeta(labels={"app": "nginx"}))
+            with pod_template.spec() as pod_spec:
+                with pod_spec.containers() as container_list:
+                    with container_list.add() as nginx_container:
+                        # Complete IDE support regardless of style
+                        nginx_container.name("nginx")
+                        nginx_container.image("nginx:latest")
+                        # Switch styles any time
+                        nginx_container.ports(lambda ports: ports
+                            .add(lambda p: p.container_port(80))
+                            .add(lambda p: p.container_port(443))
+                        )
+
+final_deployment = nginx_deployment.build()
+```
+
+This flexibility allows you to:
+- 🔀 Choose the most appropriate style for each part of your configuration
+- 📖 Maximize readability for both simple and complex structures
+- 🎨 Format your code according to your team's preferences
+- 🧠 Get full IDE support with automatic style detection
+- ✨ Enjoy rich autocomplete in all styles
+- ⚡ Benefit from type checking across mixed styles
+- 🎯 Receive immediate feedback on type errors
+- 🔍 See documentation for all fields regardless of style
+
 
 ### Creating Resources
 
@@ -388,7 +628,7 @@ Cloudcoil supports generating typed models from CustomResourceDefinitions (CRDs)
 
 ### Using the Cookiecutter Template
 
-The fastest way to get started is using our cookiecutter template: [cloudcoil-models-cookiecutter](https://github.com/cloudcoil/cloudcoil-models-cookiecutter)
+The fastest way to get started is using our cookiecutter template: [cloudcoil-models-cookiecutter](https://github.com/cloudcoil/cloudcoil/tree/main/cookiecutter)
 
 ### Codegen Config