semvec/pypi-packages huggingface dataset:
simpledevsecops 0.1.1
Interactive DevSecOps Pipeline Generator
Requires Python: >=3.8

# PipelineGen

**Interactive DevSecOps CI/CD Pipeline Generator**

PipelineGen is a command-line tool that automatically generates **secure, production-ready DevSecOps pipelines** for GitHub Actions.
It asks simple interactive questions and produces a fully optimized pipeline with:

* OIDC authentication
* SAST, SCA, secret scanning
* Docker multi-arch builds
* Coverage reports
* SonarQube integration
* Deployment workflows
* Professional comments + formatted YAML

No YAML knowledge required — just answer the prompts and your pipeline is ready.

---

## ✨ Features

### 🔧 Technology Support

✔ Java (Maven / Gradle)
✔ Python
✔ Node.js
✔ Go (coming soon)
✔ .NET (coming soon)

### 🔒 Security Built-in

* SpotBugs / Bandit (SAST)
* Trivy filesystem & image scanning
* Gitleaks secret detection
* SARIF reports
* OIDC authentication for AWS

### 🐳 Containerization

* Docker build
* Buildx
* Multi-architecture images
* ECR login (via OIDC)
* Layer caching for faster builds

### 🧪 Testing & Coverage

* JUnit / PyTest / Jest support
* Auto-generated test artifacts
* Code coverage upload
* Compatible with SonarQube

### 🚀 Deployment

* AWS ECS
* AWS EKS
* Lambda
* Kubernetes
* Or no deployment (if not needed)

---

## 📦 Installation

Install from PyPI:

```
pip install simpledevsecops
```

---

## ▶️ Usage

Run the generator:

```
simpledevsecops
```

Follow the interactive prompts:

* Choose language
* Select build tool
* Enable/disable security scans
* Choose deployment target
* Enable caching / concurrency
* Set job timeouts
* Choose filename

After answering, your pipeline is generated inside:

```
generated-pipelines/<your-pipeline-name>.yaml
```

---

## 📁 Example Output

```
generated-pipelines/
└── java-devsecops-pipeline.yaml
```

The file includes:

* Step-by-step comments
* Security markers
* Optimized job ordering
* Ready-to-run GitHub Actions pipeline

---

## 🔐 Required Secrets (Based on your choices)

* AWS_ROLE_ARN
* AWS_ACCOUNT_ID
* AWS_ACCESS_KEY_ID
* AWS_SECRET_ACCESS_KEY
* SONAR_TOKEN

Automatically detected and shown after generation.

---

## ⚙️ Why Use PipelineGen?

* No need to manually create YAML files
* Ensures best practices for DevSecOps
* Generates pipelines with consistent structure
* Supports multiple languages
* Saves hours of configuration work
* Perfect for both beginners and senior engineers

---

## 🤝 Contributing

Pull requests and feature requests are welcome!
Feel free to open issues if you want new features like:

* Terraform CI integration
* Azure DevOps support
* GitLab CI support
* Template packs

---

## 🧑‍💻 Author

**Sourav Kumar**
Email: [1109souravkumar@gmail.com](mailto:1109souravkumar@gmail.com)
dishka-strawberry 0.2.0
Dishka integration for Strawberry
Requires Python: >=3.10

# dishka-strawberry

*dishka-strawberry* will help you use [Dishka](https://github.com/reagento/dishka) with [Strawberry](https://github.com/strawberry-graphql/strawberry). It features:

* automatic injection of dependencies into GraphQL resolver functions
* integration with FastAPI through `strawberry.fastapi.GraphQLRouter`

## Installation

Install using pip:

```shell
pip install dishka-strawberry
```

Or using uv:

```shell
uv add dishka-strawberry
```

## How to use

### 1. Import

```python
from dishka_strawberry.fastapi import (
    FromDishka,
    inject,
)
from dishka.integrations.fastapi import (
    FastapiProvider,
    setup_dishka,
)
from dishka import make_async_container, Provider, provide, Scope
```

### 2. Create provider

You can use `FastapiProvider` as a base class if you need to access `fastapi.Request` in your providers

```python
class AppProvider(FastapiProvider):
    @provide(scope=Scope.REQUEST)
    def create_message(self) -> Message:
         return Message("42")
```

### 3. Mark resolver parameters

Mark resolver parameters which are to be injected with `FromDishka[]` and decorate them using `@inject`

```python
@strawberry.type
class Query:
    @strawberry.field
    @inject
    def answer(self, message: FromDishka[Message]) -> MessageGQL:
        return MessageGQL(message=message)
```

### 4. Create Strawberry schema

Create Strawberry schema and integrate it with FastAPI using `GraphQLRouter`

```python
schema = strawberry.Schema(query=Query)
graphql_router = GraphQLRouter(schema)

app = FastAPI()
app.include_router(graphql_router, prefix="/graphql")
```

### 5. Setup dishka integration

Setup `dishka` integration for FastAPI (which will handle the container lifecycle for GraphQL requests as well)

```python
container = make_async_container(AppProvider())
setup_dishka(container=container, app=app)
```

## Contributing

Contributors are welcome! If you'd like to contribute to this project, please feel free to open an issue or submit a pull request.