MERMS/MermsCoreFlask
1
0
Fork 0
Code Issues Pull Requests Releases Activity

generative data

Browse Source
This commit is contained in:
CHIEFSOFT\ameye
2025-09-06 11:48:37 -04:00
parent f992bc8bfe
commit ff3ff1c6ba
9 changed files with 206 additions and 70 deletions
Download Patch File Download Diff File Expand all files Collapse all files
SQL/site_data.sql
+19 -1
View File
@@ -589,6 +589,7 @@ CREATE TABLE subscription_generative(
member_id INT REFERENCES members(id) UNIQUE NOT NULL,
practice VARCHAR(100) NOT NULL,
specialization VARCHAR(100) NOT NULL,
product_id VARCHAR(25) NOT NULL,
subscription_uid VARCHAR(100) NOT NULL,
status INT DEFAULT 0,
added timestamp without time zone DEFAULT now()
@@ -597,7 +598,24 @@ CREATE TABLE subscription_generative(
ALTER TABLE ONLY subscription_generative
ADD CONSTRAINT subscription_generative_id_key UNIQUE (id);
ALTER TABLE subscription_generative OWNER TO merms_panel
ALTER TABLE subscription_generative OWNER TO merms_panel;
CREATE TABLE generative_results(
id SERIAL,
uid uuid DEFAULT uuid_generate_v4(),
member_id INT REFERENCES members(id) NOT NULL,
product_id VARCHAR(25) NOT NULL,
var_name VARCHAR(100) NOT NULL,
subscription_uid VARCHAR(100) NOT NULL,
text_result TEXT,
status INT DEFAULT 0,
added timestamp without time zone DEFAULT now()
);
ALTER TABLE ONLY generative_results
ADD CONSTRAINT generative_results_id_key UNIQUE (id);
ALTER TABLE generative_results OWNER TO merms_panel;
app/api/enums/generatives_list.py
+4 -4
View File
@@ -3,9 +3,9 @@ class GenerativesList:
@staticmethod
def get_generative_list():
data = [
{"name": 'site_title', "prompt": 'Write about a 30-character title text for a REPLACE_THIS website.', "active": True},
{"name": 'site_description', "prompt": 'Write a short introduction text about 100 characters for a REPLACE_THIS website.', "active": True},
{"name": 'about_title', "prompt": 'Write about a 30-character about page title text for a REPLACE_THIS website.', "active": True},
{"name": 'about_description', "prompt": 'Write three paragraphs about a REPLACE_THIS website.', "active": True},
{"name": 'site_title', "prompt": 'Write about a 30-character title text for a REPLACE_THIS with specialization in REPLACE_ANOTHER website.', "active": True},
{"name": 'site_description', "prompt": 'Write a short introduction text about 100 characters for a REPLACE_THIS with specialization in REPLACE_ANOTHER website.', "active": True},
{"name": 'about_title', "prompt": 'Write about a 30-character about page title text for a REPLACE_THIS with specialization in REPLACE_ANOTHER website.', "active": True},
{"name": 'about_description', "prompt": 'Write three paragraphs about a REPLACE_THIS with specialization in REPLACE_ANOTHER website.', "active": True},
]
return data
app/api/services/genaratives.py
+67 -20
View File
@@ -4,8 +4,7 @@ from app.utils.logger import logger
from app.api.services.base_service import BaseService
from marshmallow import ValidationError
from app.extensions import db
from app.models import MembersProducts, Products, Members, ProductsDetails, ProductsDetails, ProvisionActions, \
MembersProductsSettings, ProductsTemplates
from app.models import SubscriptionGenerative, GenerativeResults
from app.api.enums import GenerativesList
@@ -13,23 +12,71 @@ class GenerativesService(BaseService):
@staticmethod
def process_generatives_list(data):
logger.info("ENTER GENERATIVE")
generate_list = GenerativesList.get_generative_list()
practice_type = "Dentist"
subscription_uid =" a42dbcc2-7466-4bea-aa67-8357c2c33925"
product_id ="A000001"
logger.info("SELECT GENERATIVE")
planed_generate_list = SubscriptionGenerative.get_subscription_generative_list_by_status(0)
if planed_generate_list:
for t in planed_generate_list:
logger.info(f"SELECT GENERATIVE {t}")
practice_type = t.practice
specialization = t.specialization
subscription_uid = t.subscription_uid
product_id = t.product_id
member_id = t.member_id
status = t.status
# logger.info(f"GenerativesService ****** *****: {member_id} {practice_type} {product_id} {subscription_uid}")
SubscriptionGenerative.update_subscription_generative_status(subscription_uid,status+1) # move the status up
GenerativesService.process_generatives_action(member_id, practice_type,specialization,subscription_uid,product_id)
@staticmethod
def process_generatives_action(member_id, practice_type,specialization,subscription_uid,product_id):
try:
logger.info("ENTER GENERATIVE")
generate_list = GenerativesList.get_generative_list()
GenerativeResults.create_generative_result(71, 'A000001', 'about_title',
'35e2d3ba-b5a6-4c1b-b962-05661d55b6f4',
'Expert Neurologist: Brain & Nerve Care')
# with db.session.begin():
for t in generate_list:
prompt_string = str(t["prompt"]).replace("REPLACE_THIS", practice_type).replace("REPLACE_ANOTHER",
specialization)
var_name = t["name"]
logger.info(f"GenerativesService ****** *****: {t['name']} {prompt_string}")
json_response = None
# json_response = GenerativeEngineIntegration.ask_generative(prompt_string)
# INFO - INSERT *****:71 A000001 about_title 35e2d3ba-b5a6-4c1b-b962-05661d55b6f4 Expert Neurologist: Brain & Nerve Care
GenerativeResults.create_generative_result(71, 'A000001', 'about_title',
'35e2d3ba-b5a6-4c1b-b962-05661d55b6f4',
'Expert Neurologist: Brain & Nerve Care')
if json_response is not None:
logger.info(json_response)
# logger.info(json_response["output"])
# logger.info(json_response["output"][0])
# logger.info(json_response["output"][0]["content"][0]["text"])
text_result = json_response["output"][0]["content"][0]["text"]
logger.info(
f"INSERT *****:{member_id} {product_id} {var_name} {subscription_uid} {text_result}")
GenerativeResults.create_generative_result(member_id, product_id, var_name, subscription_uid,
text_result)
except ValidationError as err:
logger.error(f"Validation Error: {getattr(err, 'messages', str(err))}")
db.session.rollback()
# return ResponseHelper.unprocessable_entity(result_description="Validation exception")
except ValueError as err:
logger.error(f"{getattr(err, 'messages', str(err))}")
db.session.rollback()
# return ResponseHelper.error(result_description=str(err))
except Exception as e:
logger.error(f"An error occurred: {str(e)}", exc_info=True)
db.session.rollback()
# return ResponseHelper.internal_server_error()
for t in generate_list:
prompt_string = str(t["prompt"]).replace("REPLACE_THIS", practice_type)
var_name = t["name"]
logger.info(f"GenerativesService ****** *****: {t['name']} {prompt_string}")
json_response = []
# json_response = GenerativeEngineIntegration.ask_generative(prompt_string)
if json_response is not None:
logger.info(json_response)
logger.info(json_response["output"])
logger.info(json_response["output"][0])
logger.info(json_response["output"][0]["content"][0]["text"])
text_result= json_response["output"][0]["content"][0]["text"]
logger.info(f"INSERT *****: {product_id} {var_name} {subscription_uid} {text_result}")
app/api/services/myproduct.py
+1 -1
View File
@@ -231,7 +231,7 @@ class MyProductsService(BaseService):
practice = profile_data.practice
specialization = profile_data.specialization
subscription_uid = subscription.uid
SubscriptionGenerative.create_subscription_generative(member_id ,practice,specialization,subscription_uid)
SubscriptionGenerative.create_subscription_generative(member_id ,practice,specialization,product_id, subscription_uid)
response_data = {
"subscription_uid": subscription.uid,
app/models/__init__.py
+2 -1
View File
@@ -16,11 +16,12 @@ from .products_templates import ProductsTemplates
from .payments_session import PaymentsSession
from .payments import Payments
from .subscription_generative import SubscriptionGenerative
from .generative_results import GenerativeResults
__all__ = ['Members', 'Account', 'Products',
'MembersProducts', 'MembersActions', 'MembersPending', 'ProductsDetails',
'ProvisionActions', 'MembersProductsRefresh','MembersProductsSettings',
'PasswordReset','MembersProfile','SubscriptionOptions','SubscriptionOptionsItems',
'ProductsTemplates','Payments','PaymentsSession','SubscriptionGenerative']
'ProductsTemplates','Payments','PaymentsSession','SubscriptionGenerative','GenerativeResults']
app/models/generative_results.py
+95
View File
@@ -0,0 +1,95 @@
from datetime import datetime, timezone, timedelta
from itertools import product
from app.extensions import db
from sqlalchemy.exc import IntegrityError
from sqlalchemy.orm import relationship
from dateutil.relativedelta import relativedelta
from datetime import timedelta
import logging
from sqlalchemy import and_, or_, not_
from sqlalchemy.sql import func
import uuid
logger = logging.getLogger(__name__)
class GenerativeResults(db.Model):
__tablename__ = 'generative_results'
id = db.Column(
db.Integer,
primary_key=True,
autoincrement=True,
)
uid = db.Column(db.String(150), nullable=False)
member_id = db.Column(db.Integer, nullable=False)
product_id = db.Column(db.String(25), nullable=False)
var_name = db.Column(db.String(100), nullable=False)
subscription_uid = db.Column(db.String(100), nullable=False)
text_result = db.Column(db.String(14000), nullable=False)
status = db.Column(db.Integer, nullable=True, default=0)
added = db.Column(db.DateTime(timezone=True), server_default=func.now())
@classmethod
def get_subscription_generative_by_subscription_uid(cls, subscription_uid):
subscription_generative = cls.query.filter_by(subscription_uid=str(subscription_uid)).first()
if not subscription_generative:
return None
return subscription_generative
@classmethod
def get_subscription_generative_list_by_status(cls, status):
subscription_generative = cls.query.filter_by(status=status).all()
if not subscription_generative:
return None
return subscription_generative
@classmethod
def update_subscription_generative_status(cls, subscription_uid, status):
subscription_generative = cls.query.filter_by(subscription_uid=str(subscription_uid)).first()
if not subscription_generative:
logger.error(f"SubscriptionGenerative with Sub UID {subscription_uid} does not exist.")
return None
subscription_generative.status =status
return status
@classmethod
def create_generative_result(cls, member_id,product_id,var_name,subscription_uid,text_result):
# create_generative_result(member_id,product_id,var_name,subscription_uid,text_result)
logger.info(f"GenerativeResults Create::Data {member_id} ,{product_id} ,{var_name} , {subscription_uid},{text_result} ")
subscription_generative_data = cls(
uid=str(uuid.uuid4()),
member_id=member_id,
var_name=var_name,
text_result=text_result,
product_id=product_id,
subscription_uid=subscription_uid,
added=datetime.now(timezone.utc)
)
try:
logger.info(f" About to Insert GenerativeResults Data {subscription_generative_data.member_id} ")
db.session.add(subscription_generative_data)
db.session.flush()
except IntegrityError as err:
logger.error(f" Error inserting GenerativeResults data {err} -- ")
raise ValueError(f"Database integrity error: {err}")
return subscription_generative_data
def to_dict(self):
return {
'id': self.id,
'uid': self.uid,
'member_id': self.member_id,
'product_id': self.product_id,
'var_name': self.var_name,
'subscription_uid': self.subscription_uid,
'text_result': self.text_result,
'status': self.status,
'added': self.added
}
def __repr__(self):
return f'<GenerativeResults {self.id}>'
app/models/members_pending.py
-29
View File
@@ -55,38 +55,9 @@ class MembersPending(db.Model):
@classmethod
def get_member_by_username(cls, username):
"""
Return an offer by its ID.
"""
member = cls.query.filter_by(username=str(username)).first()
if not member:
raise ValueError(f"Username = {username} not found")
return member
# {
# "email": "ameye@chiefsoft.com",
# "firstname": "Olusesan",
# "lastname": "Ameye",
# "isChecked": true
# }
'''
merms_panel=# \d members_pending
Table "public.members_pending"
Column | Type | Collation | Nullable | Default
-----------+-----------------------------+-----------+----------+---------------------------------------------
id | integer | | not null | nextval('members_pending_id_seq'::regclass)
uid | uuid | | | uuid_generate_v4()
firstname | character varying(35) | | not null |
lastname | character varying(35) | | not null |
email | character varying(35) | | not null |
status | integer | | | 0
added | timestamp without time zone | | | now()
updated | timestamp without time zone | | | now()
Indexes:
"members_pending_id_key" UNIQUE CONSTRAINT, btree (id)
merms_panel=#
'''
app/models/members_products.py
-1
View File
@@ -78,7 +78,6 @@ class MembersProducts(db.Model):
member_product.product_template = product_template
return product_template
@classmethod
def create_subscription(cls, member_id ,product_id,status,internal_url):
dns_group = "DNS_G01"
app/models/subscription_generative.py
+18 -13
View File
@@ -25,7 +25,8 @@ class SubscriptionGenerative(db.Model):
member_id = db.Column(db.Integer, nullable=False)
practice = db.Column(db.String(100), nullable=False)
specialization = db.Column(db.String(100), nullable=False)
subscription_uid = db.Column(db.String(3500), nullable=True)
product_id = db.Column(db.String(25), nullable=False)
subscription_uid = db.Column(db.String(100), nullable=True)
status = db.Column(db.Integer, nullable=True, default=0)
added = db.Column(db.DateTime(timezone=True), server_default=func.now())
@@ -37,32 +38,35 @@ class SubscriptionGenerative(db.Model):
return subscription_generative
@classmethod
def get_subscription_generative_list_by_status(cls, subscription_uid, status):
subscription_generative = cls.query.filter_by(subscription_uid=str(subscription_uid)).all()
def get_subscription_generative_list_by_status(cls, status):
subscription_generative = cls.query.filter_by(status=status).all()
if not subscription_generative:
return None
return subscription_generative
@classmethod
def update_subscription_generative_status(cls, subscription_uid, status):
# Retrieve Reset
subscription_generative = cls.query.filter_by(subscription_uid=str(subscription_uid)).first()
if not subscription_generative:
raise ValueError(f"SubscriptionGenerative with Sub UID {subscription_uid} does not exist.")
subscription_generative.status =status
logger.info(
f"UPDATE SubscriptionGenerative::status subscription_uid = {subscription_uid} status = {status} ")
subscription_generative_data = cls.query.filter_by(subscription_uid=str(subscription_uid)).first()
# member_product = cls.query.filter_by(member_id=str(member_id), product_id=str(product_id)).first()
if not subscription_generative_data:
logger.error(f"SubscriptionGenerative with Sub UID {subscription_uid} does not exist.")
return None
logger.info("INSERT::Point-->")
subscription_generative_data.status = status
return subscription_generative_data.status
@classmethod
def create_subscription_generative(cls, member_id ,practice,specialization,subscription_uid):
def create_subscription_generative(cls, member_id ,practice,specialization,product_id, subscription_uid):
logger.info(f"SubscriptionGenerative Data {member_id} ,{practice} ,{specialization}, {subscription_uid} ")
logger.info(f"SubscriptionGenerative Data {member_id} ,{practice} ,{specialization},{product_id}, {subscription_uid} ")
subscription_generative_data = cls(
uid=str(uuid.uuid4()),
member_id=member_id,
practice=practice,
specialization=specialization,
product_id=product_id,
subscription_uid=subscription_uid,
added=datetime.now(timezone.utc)
)
@@ -85,6 +89,7 @@ class SubscriptionGenerative(db.Model):
'member_id': self.member_id,
'practice': self.practice,
'specialization': self.specialization,
'product_id': self.product_id,
'subscription_uid': self.subscription_uid,
'added': self.added,
'status': self.status