I have migrated from trulens_eval to trulens and I am now facing a "module 'trulens.core.utils.threading' has no attribute 'Lock'" error.

[emmanouilvoitsidis]

I have migrated from trulens_eval to trulens and I am now facing a "module 'trulens.core.utils.threading' has no attribute 'Lock'" error.

My new imports are:

from trulens.core import TruSession
from trulens.core import Feedback
from trulens.providers.openai import OpenAI as fOpenAI

And the previous ones are:

from trulens_eval import Tru
from trulens_eval import Feedback
from trulens_eval.feedback.provider.openai import OpenAI as fOpenAI

I have made the change from Tru to TruSession in my code. I am in version 2.3.1. I couldn't find anything relevant in the documentation. Any idea why this is happening? Thanks.

[dosubot[bot]]

The error happens because Lock is not defined in trulens.core.utils.threading in trulens 2.3.1. In the new package structure, threading primitives like Lock are not re-exported by trulens; you should import them directly from Python's standard library: from threading import Lock example.

Also, for your imports:

• TruSession should be imported from trulens.core.session, not directly from trulens.core.
• Feedback should be imported from trulens.core.feedback.feedback.
• The OpenAI provider should be imported from trulens.providers.openai.provider see migration guide.

So, your updated imports should look like:

from trulens.core.session import TruSession
from trulens.core.feedback.feedback import Feedback
from trulens.providers.openai.provider import OpenAI as fOpenAI
from threading import Lock  # if you need Lock

If you have any lingering references to trulens.core.utils.threading.Lock in your code or dependencies, update them to use the standard library import instead.

To reply, just mention @dosu.

---

^{How did I do? Good | Irrelevant | Incorrect | Verbose | Hallucination | Report 🐛 | Other}

   

[emmanouilvoitsidis]

@sfc-gh-jreini Many thanks. I am new to TruLens and really want to use it for my prototype, but a bit lost with the different issues at the moment. This migration (which caused the error) is an attempt to resolve this issue: #2299, so any help with this directly would be even more appreciated. Thanks.

[sfc-gh-jreini]

Hi @emmanouilvoitsidis can you please try creating a new python environment and installing the following trulens libraries in the latest version? Just tested in a fresh env and your imports will work as is:

trulens-core==2.5.1
trulens-providers-openai==2.5.1
trulens-feedback==2.5.1

[emmanouilvoitsidis]

Hi @sfc-gh-jreini I have followed the steps above:

trulens-core                             2.5.1
trulens-feedback                         2.5.1
trulens-otel-semconv                     2.5.1
trulens-providers-openai                 2.5.1

I am for some reason facing the following error when I try to run my application (I have installed the exact same packages as before in my new environment): ModuleNotFoundError: No module named 'langchain.prompts'

For context, these are the langchain packages I have installed:

langchain                                1.1.0
langchain-classic                        1.0.0
langchain-community                      0.4.1
langchain-core                           1.1.0
langchain-openai                         1.1.0
langchain-text-splitters                 1.0.0
langchainhub                             0.1.21

[sfc-gh-jreini]

Can you share a small, reproducible example so I can try the error and help troubleshoot?

[emmanouilvoitsidis]

@sfc-gh-jreini It's part of a larger application, so not sure how I can distil it into a smaller example. The code I run during inference is as below:

import json
os.environ["TRULENS_OTEL_TRACING"] = "0"
from dotenv import load_dotenv
from fastapi import FastAPI, HTTPException
from langchain_community.vectorstores import Chroma
from langchain_openai import OpenAIEmbeddings, ChatOpenAI
from langchain.prompts import PromptTemplate
from langchain.schema.runnable import RunnablePassthrough
from langchain.schema.output_parser import StrOutputParser
from langchain.retrievers.multi_query import MultiQueryRetriever
from models import QueryRequest, UserProfile

# --- TRULENS 2.3.1 IMPORTS ---
# from trulens.core import TruSession
# from trulens.core import Feedback
# from trulens.providers.openai import OpenAI as fOpenAI
from trulens.core import TruSession
from trulens.core import Feedback
from trulens.providers.openai import OpenAI as fOpenAI
# --- END TRULENS IMPORTS ---

# --- 1. Configuration and Setup ---
# Load environment variables
load_dotenv()
if not os.getenv("OPENAI_API_KEY"):
    raise Exception("OpenAI API key not found. Please set it in the .env file.")

# Define constants
VECTOR_DB_PATH = "vector_db"
LLM_MODEL_NAME = "gpt-4o"


print("--- RAG Application Initializing ---")

try:
    # Load the embedding model
    embeddings = OpenAIEmbeddings(model="text-embedding-3-small")
    # Load the vector database once at startup
    vector_db = Chroma(persist_directory=VECTOR_DB_PATH, embedding_function=embeddings)
    # Initialize the LLM
    llm = ChatOpenAI(model_name=LLM_MODEL_NAME, temperature=0.1)
    print("--- Initialization Complete. Application is Ready. ---")

except Exception as e:
    print(f"Error during initialization: {e}")
    raise

# Define the Prompt Template (keep your existing template)
prompt_template = """
...
"""
prompt = PromptTemplate(template=prompt_template, input_variables=["context", "question"])


# --- TRULENS 2.3.1 SETUP ---
tru = TruSession()
provider = fOpenAI()

f_answer_relevance = Feedback(
    provider.relevance,
    name="Answer Relevance"
).on_input_output()

# --- END TRULENS SETUP ---

# --- 2. NEW: Metadata Filter Generation Logic ---

def create_metadata_filter(profile: UserProfile) -> dict:
    """
    Creates a ChromaDB metadata filter dictionary based on the user's profile.
    """
    print("--- Creating Metadata Filter ---")
    filters = []

    user_risk = profile.risk_tolerance.value
    allowed_risks = []
    if user_risk == "Low":
        allowed_risks = ["Low"]
    elif user_risk == "Medium":
        allowed_risks = ["Low", "Medium"]
    elif user_risk == "High":
        allowed_risks = ["Low", "Medium", "High"]
    
    if allowed_risks:
        filters.append({
            "risk_level": {"$in": allowed_risks}
        })
        print(f"Filtering for risk levels: {allowed_risks}")

  
    

    if len(filters) == 1:
        print("Single filter condition, returning filter directly")
        print(filters[0])
        return filters[0]

    print("Multiple filter conditions, using $and operator")
    print(filters)
    return {"$and": filters}


# --- 3. FastAPI Application Endpoint ---

# FastAPI app and endpoint
app = FastAPI(
    title="...",
    description="...",
    version="1.0.0"
)

def format_user_query(profile, unstructured_text):
    profile_summary = (
        f"The investor has a {profile.risk_tolerance.value} risk tolerance "
    )
    full_query = (
        "Here is the user's profile and objectives:\n\n"
        f"Investor Profile Summary:\n{profile_summary}\n\n"
        f"Investor's Personal Goals and Motivation:\n{unstructured_text}"
    )
    return full_query

@app.post("/generate-recommendation")
async def generate_recommendation(request: QueryRequest):
    try:
        final_query = format_user_query(request.profile, request.unstructured_text)
                
        metadata_filter = create_metadata_filter(request.profile)
        print(metadata_filter)
        
        base_retriever = vector_db.as_retriever(
            search_kwargs={"k": 20, "filter": metadata_filter}
        )
        
        retriever = MultiQueryRetriever.from_llm(
            retriever=base_retriever, llm=llm
        )
        
        rag_chain = (
            {"context": retriever, "question": RunnablePassthrough()}
            | prompt
            | llm
            | StrOutputParser()
        )

        tru_recorder = tru.Chain(
            rag_chain,
            app_id='InvestmentAdvisor_RAG_v2.0',
            feedbacks=[f_answer_relevance] # Removed f_context_relevance and f_faithfulness for simplicity
        )
        
        with tru_recorder as recording:
            print("Invoking RAG chain with metadata filter...")
            response = rag_chain.invoke(final_query)
            
        return {"recommendation": response}

    except Exception as e:
        print(f"An error occurred: {e}")
        raise HTTPException(status_code=500, detail=str(e))

@app.get("/tru-dashboard")
async def launch_dashboard():
    """
    Launch the TruLens dashboard
    """
    import threading
    import webbrowser
    import time
    
    def start_dashboard():
        time.sleep(2)  # Give the endpoint time to respond
        tru.run_dashboard()
    
    # Start dashboard in a separate thread
    thread = threading.Thread(target=start_dashboard)
    thread.daemon = True
    thread.start()
    
    return {"message": "TruLens dashboard starting...", "url": "http://localhost:..."}

I understand you cannot use this to reproduce the problem, but hopefully it gives a better indication of what the issue may be. If there is a way to help reproduce it that I am overlooking, please let me know.

My installed libraries include:
langchain
langchain-openai
langchain-community
"unstructured[pdf]"
chromadb
openai
sentence-transformers
python-dotenv
streamlit requests
plus the TruLens packages you recommended above

I should add that this didn't occur when I was using the older trulens_eval packages. The reason I tried to migrate was in the hope of fixing issue #2299