DEV Community: Lokesh Velayudham - lowkeyy.eth

Flask(Python) + CRUD ( Postman) +MongoDB + Docker

Lokesh Velayudham - lowkeyy.eth — Thu, 10 Aug 2023 15:23:43 +0000

An application on pyhton- flask framework, for CRUD operations test it using postman application and use monogodb to access and delete the data and dockerize the application

An appliction for CRUD operations on MongoDB using flask+python backend and build REST API, The REST API endpoints should be accessible via HTTP requests and tested using Postman.

The application should connect to a MongoDB database.
The application should provide the following REST API endpoints:

-1.GET /users - Returns a list of all users.
-2.GET /users/<id> - Returns the user with the specified ID.
-3.POST /users - Creates a new user with the specified data.
-4.PUT /users/<id> - Updates the user with the specified ID with the new data.
-5.DELETE /users/<id> - Deletes the user with the specified ID.

Setup and installation
1. Create a virtual environment 
   1.  ```

python3 -m venv venv

source venv/bin/activate 3. create a new file in the directoty named app.py

To install Flask and pyMongo using pip install
1. pip install Flask pymongo 2. import the flask and pymongo into the app.py ```

App.py: https://github.com/lokeshvelayudham/corider_assignment

# import flask and pyMongo, bson
from bson import ObjectId
from flask import Flask, jsonify, request
from flask_pymongo import PyMongo


app = Flask(__name__)

# Configure the Flask app to connect to your MongoDB database
app.config['MONGO_URI'] = 'mongodb://localhost:27017/corider'
mongo = PyMongo(app)

# Define the User collection
users = mongo.db.users


# GET /users - Returns a list of all users.
@app.route('/users', methods=['GET'])
def get_all_users():
    user_list = []
    for user in users.find():
        user_list.append({
            'id': str(user['_id']),
            'name': user['name'],
            'email': user['email']
        })
    return jsonify(user_list)



# GET /users/<id> - Returns the user with the specified ID.
@app.route('/users/<id>', methods=['GET'])
def get_user(id):
    user = users.find_one_or_404({'_id': ObjectId(id)})
    return jsonify({
        'id': str(user['_id']),
        'name': user['name'],
        'email': user['email']
    })


# POST /users - Creates a new user with the specified data.
@app.route('/users', methods=['POST'])
def create_user():
    data = request.get_json()
    user_id = users.insert_one(data).inserted_id
    return jsonify({'message': 'User created successfully', 'id': str(user_id)})


# PUT /users/<id> - Updates the user with the specified ID with the new data.
@app.route('/users/<id>', methods=['PUT'])
def update_user(id):
    data = request.get_json()
    users.update_one({'_id': ObjectId(id)}, {'$set': data})
    return jsonify({'message': 'User updated successfully'})


# DELETE /users/<id> - Deletes the user with the specified ID.
@app.route('/users/<id>', methods=['DELETE'])
def delete_user(id):
    users.delete_one({'_id': ObjectId(id)})
    return jsonify({'message': 'User deleted successfully'})

Install & Setup MongoDb Databsae using homebrew
1. install MongoDb community in the local 1. brew install mongodb-community@6.0
2. To Start mongoDb server 1. brew services start mongodb-community@6.0
3. After starting the server open a new terminal 1. mongo
2.

use Collection

3.

To insert the data into the db

```db.users.insert({
    "name": "John Doe",
    "email": "john@example.com",
    "password": "secretpassword"
    })```

To Test :

Testing the Application using CRUD
1. Test in the POSTMAN
2. install postman desktop agent
  1. The REST API endpoints:
    1. GET /users - Returns a list of all users.
    2. GET /users/ - Returns the user with the specified ID.
    3. POST /users - Creates a new user with the specified data.
    4. PUT /users/ - Updates the user with the specified ID with the new data.
    5. DELETE /users/ - Deletes the user with the specified ID.

To dockerize :

Create a file named Dockerfile

requirements.txt

Flask-PyMongo==2.3.0```

3. create a yml file
4. Build and run 
docker-compose build
docker-compose up
5. push the docker into hub
1. list the docker images -

``` docker images```

2. login into docker -

```docker login```

enter username and password
3. create a image tag docker tag IMAGE NAME HUBNAME/IMAGE NAME -

```docker tag corider_assignment-app lokeshbx/corider_assignment-app```

4. docker push IMAGE - docker push lokeshbx/corider_assignment-app

Dockerfile

# Use the official Python image as the base image
FROM python:3.8

# Set environment variables for Flask
ENV FLASK_APP=app.py
ENV FLASK_RUN_HOST=0.0.0.0

# Set up a working directory
WORKDIR /Users/lokesh/Downloads/2022/web2/corider_assignment

# Copy requirements file and install dependencies
COPY requirements.txt ./
RUN pip install --no-cache-dir -r requirements.txt

# Copy the application code into the container
COPY . .

# Expose the port that the application runs on
EXPOSE 5000

# Run the application
CMD ["flask", "run"]

video : https://youtu.be/SlQMuN_IvRY
Docker :https://hub.docker.com/repository/docker/lokeshbx/corider_assignment-app/general

The Ultimate Guide to Enhancing Your Sales with Stable Diffusion API and Printfy API

Lokesh Velayudham - lowkeyy.eth — Tue, 01 Aug 2023 11:34:12 +0000

Using a stable diffusion api and printfy api: Breaking Down the Process

Github. : https://github.com/lokeshvelayudham/stability-printfyapiAi

For more connect with me @ Linkedin

If you're in the world of AI, you've probably heard of Stable
diffusion . It's a powerful tool that transforms text into high-resolution, high-quality images. With an easy-to-use platform and a dynamic user community, it's become a standout tool in the digital landscape.

Use Stable diffusion ai to generate image and use printfy api to publish it in the printfy - shopify store

The Stable diffusion offers an API to generate an text to Image generative AI, Where the images are stored in locally/ MongoDB and those images are uploaded to the store using printfy api

To Generate an Image, We are using Stability diffusion -
We will be requiring open API key and Stability diffusion AI key
function to generate an Images and stored

`for idx, row in tqdm(df.iterrows(), total=df.shape[0]):
detail = row['details']

# Generate the title, description, prompt, and tags using the OpenAI API
title = generate_clickable_title(detail)
description = generate_description(detail)
image_prompt = generate_image_prompt(detail)
tag = generate_tags(detail)



# Generate the image using the Stability.ai API
url = "https://api.stability.ai/v1/generation/stable-diffusion-v1-5/text-to-image"
headers = {"Authorization": f"Bearer {stability_ai_key}", "Accept": "image/png"}
data = {
    "width": 512,
    "height": 512,
    "text_prompts": [
        {
            "text": image_prompt,
            "weight": 0.5
        }
    ]
}
response = requests.post(url, headers=headers, json=data)
image_data = response.content
image = Image.open(io.BytesIO(image_data))
file_name = f"image_{idx}.png"  
local_path = f"{file_name}"  # Save the image in the same directory
image.save(local_path)

# Append the generated data to the lists
file_names.append(file_name)
local_paths.append(local_path)
titles.append(title)
descriptions.append(description)
tags.append(tag)`

TO Upload product to the shopify-printify website

# To change the print object, use this to find the variant id curl -X GET "https://api.printify.com/v1/catalog/blueprints/1098/print_providers/228/variants.json" "Authorization: Bearer {access token}"

Find your shop ID by running this: curl -X GET https://api.printify.com/v1/shops.json --header "Authorization: Bearer {access token}"

`For idx, row in image_df.iterrows():
# Convert the image to Base64
with open(row['local_path'], "rb") as img_file:
img_b64 = base64.b64encode(img_file.read()).decode('utf-8')

# Upload the image to the Printify media library
data = {
    "file_name": row['file_name'],
    "contents": img_b64
}
response = requests.post(upload_url, headers=headers, json=data)
image_id = response.json()["id"]

# Current settings are for wall art

# Create the product with the uploaded image
data = {
    "title": row['title'],
    "description": row['description'],
    "tags": row['tags'].split(', '),  # Assuming tags are comma-separated in the CSV
    "blueprint_id": 6,  # Replace with the actual blueprint ID
    "print_provider_id": 270,
    "variants": [
        {
            "id": 12126,  # Replace with the actual variant ID
            "price": 3999,
            "is_enabled": True
        }
    ],
    "print_areas": [
        {
            "variant_ids": [82064],  # Replace with the actual variant ID
            "placeholders": [
                {
                    "position": "front",
                    "height": 3761,
                    "width": 3319,
                    "images": [
                        {
                            "id": image_id,
                            "x": 0.5,
                            "y": 0.5,
                            "scale": 1.5,
                            "angle": 0
                        }
                    ]
                }
            ]
        }
    ]
}
response = requests.post(product_url, headers=headers, json=data)
if response.status_code >= 200 and response.status_code < 300:
    print(f"Product {idx+1} created successfully!")
else:
    print(f"Failed to create product {idx+1}. Server responded with: {response.text}")