semvec/pypi-packages huggingface dataset:
synthesize 0.0.6
A flexible concurrent command runner.
Requires Python: >=3.10

# Synthesize

[![PyPI](https://img.shields.io/pypi/v/synthesize)](https://pypi.org/project/synthesize)
[![PyPI - License](https://img.shields.io/pypi/l/synthesize)](https://pypi.org/project/synthesize)
[![Docs](https://img.shields.io/badge/docs-exist-brightgreen)](https://www.synth.how)

[![pre-commit.ci status](https://results.pre-commit.ci/badge/github/JoshKarpel/synthesize/main.svg)](https://results.pre-commit.ci/latest/github/JoshKarpel/synthesize/main)
[![codecov](https://codecov.io/gh/JoshKarpel/synthesize/branch/main/graph/badge.svg?token=2sjP4V0AfY)](https://codecov.io/gh/JoshKarpel/synthesize)
[![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)

[![GitHub issues](https://img.shields.io/github/issues/JoshKarpel/synthesize)](https://github.com/JoshKarpel/synthesize/issues)
[![GitHub pull requests](https://img.shields.io/github/issues-pr/JoshKarpel/synthesize)](https://github.com/JoshKarpel/synthesize/pulls)

Synthesize is a tool for managing long-lived development workflows that involve multiple tools executing concurrently,
each of which might have bespoke conditions around when and how it needs to be run or re-run.

See [the documentation](https://www.synth.how) for more information.
django-googleadsauth 0.1.0
Django app for Google Ads API authentication and basic functionality
Requires Python: >=3.7
Keywords: django, google ads, google api, authentication, oauth2, campaign management

# Django Google Ads Authentication

A Django app that provides Google Ads API authentication and basic functionality for managing campaigns.

## Features

- OAuth2 authentication with Google Ads API
- Store and manage refresh tokens
- Track campaign statuses
- Basic campaign management functionality

## Installation

Install the package using pip:

```bash
pip install django-googleadsauth
```
## local installation
1. clone the repo
2. add a volume in your docker compose setup pointing to the package directory
```shell
    volumes:
      - ./app/src:/app/src
      - ./app/logs:/app/logs
      - ./app/logs/gunicorn:/var/log/gunicorn
      - ./app/local-cdn:/app/local-cdn
      - /home/tarik/django-googleadsauth:/app/django-googleadsauth
```
3. in your `pyproject.toml` add a dependency
```shell

dependencies = [
    "django>=5.1.5",
    ...
    "django-googleadsauth @ file:///app/django-googleadsauth"
]
```
4. make sure to freeze the dependencies in the `requirements.txt file`
```shell
uv pip compile pyproject.toml -o requirements.txt 
```

## Configuration

1. Add `googleadsauth` to your `INSTALLED_APPS` in `settings.py`:

```python
INSTALLED_APPS = [
    ...
    'googleadsauth',
    ...
]
```
2. configure your `.env` file
```dotenv
GOOGLE_ADS_CLIENT_SECRET_PATH=/app/google-secret.json
GOOGLE_ADS_REDIRECT_URI=http://localhost:8082/google/oauth/redirect
GOOGLE_ADS_DEVELOPER_TOKEN=xxxxxxxx
GOOGLE_ADS_CLIENT_ID=xxxxx
GOOGLE_ADS_CLIENT_SECRET=xxxx
GOOGLE_ADS_TOKEN_URI=https://oauth2.googleapis.com/token
GOOGLE_ADS_MANAGER_ACCOUNT_ID=xxxx
```

2. Add the required Google Ads API settings to your `settings.py`:

```python
GOOGLE_ADS = {
    'CLIENT_SECRET_PATH': os.getenv('GOOGLE_ADS_CLIENT_SECRET_PATH'),
    'REDIRECT_URI': os.getenv('GOOGLE_ADS_REDIRECT_URI'),
    'DEVELOPER_TOKEN': os.getenv('GOOGLE_ADS_DEVELOPER_TOKEN'),
    'CLIENT_ID': os.getenv('GOOGLE_ADS_CLIENT_ID'),
    'CLIENT_SECRET': os.getenv('GOOGLE_ADS_CLIENT_SECRET'),
    'MANAGER_ACCOUNT_ID': os.getenv('GOOGLE_ADS_MANAGER_ACCOUNT_ID'),  # Optional
}
```

3. Include the app URLs in your project's `urls.py`:

```python
from django.urls import path, include

urlpatterns = [
    ...
    path('googleads/', include('googleadsauth.urls')),
    ...
]
```

4. Run migrations:

```bash
python manage.py migrate googleadsauth
```

## Usage

### Authentication

1. Navigate to `/googleads/auth/` to start the OAuth2 authentication flow
2. After successful authentication, the app will store the refresh token


## Development

To set up for development:

1. Clone the repository
2. Install development dependencies
3. Run the test suite

## License

MIT License
amend 0.3.1
Amend: Ensure your values are right
Requires Python: >=3.8
Keywords: amend, validation, correction, processing

# Amend

Ensure your values are right

![GitHub License](https://img.shields.io/github/license/suflaj/amend?style=flat-square)

![GitHub Tag](https://img.shields.io/github/v/tag/suflaj/amend?style=flat-square)

![GitHub Repo stars](https://img.shields.io/github/stars/suflaj/amend?style=flat-square) ![GitHub Downloads (all assets, all releases)](https://img.shields.io/github/downloads/suflaj/amend/total?style=flat-square) ![GitHub repo size](https://img.shields.io/github/repo-size/suflaj/amend?style=flat-square)


## Motivation

Often times I write a lot of boilerplate code to validate and correct certain values. I have decided to create a package to stop doing it for some of the things I use. The goals of this package:

- perform routine type validation and correction (amend!)
- do not rely on third-party libraries
  - if it's outside standard Python, amends should be handled by package maintainers
- do not overcomplicate things
  - what can easily be done with a processing pipeline should be done with a processing pipeline

Using this, hopefully, writing argument parsers and ensuring correctness in functionality should be slightly easier, while forcing people to explicitly handle more elaborate and specific use cases.

## Installation

You can install this with pip:

```bash
pip install amend
```

Alternatively, you can install this from source:
```
git clone git@github.com:suflaj/amend.git
cd amend
pip install .
```

## Running tests

Amend uses your run-of-the-mill `unittest`. Therefore, to test the whole package, you can simply do:

```bash
python3 -m unittest amend.testing
```

If you wish to test some specific module you can reference the testing module with unittest. For example, if you want to unit test built-in amendments, do:

```bash
python3 -m unittest amend.testing.unit.built_in
```

For more info on how to use `unittest`, look [here](https://docs.python.org/3/library/unittest.html).

## Things to do

This package is in beta. For it to reach a full release it will need to receive:

- ReadTheDocs documentations
- usage examples
- some actual usage (will start to substitute my boilerplate for it)

Currently, it wasn't battle tested. I put in some effort to write it well, but not necessarily optimally. However, even though I do not recommend you use this for production, you can use it for many things, and presumably it should work. If it doesn't, [create an issue](https://github.com/suflaj/amend/issues). The format doesn't really matter currently.