abstract-package-test 0.0.1__py3.11.egg

EGG-INFO/PKG-INFO

@@ -0,0 +1,18 @@
+Metadata-Version: 2.1
+Name: abstract-package-test
+Version: 0.0.1
+Summary: abstract_package_test is a Python package.
+Home-page: https://github.com/AbstractEndeavors/abstract_package_test/abstract_package_test
+Author: putkoff
+Author-email: partners@abstractendeavors.com
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.6
+Description-Content-Type: text/markdown
+License-File: LICENSE
+
+# This is the README for project abstract_package_test

EGG-INFO/SOURCES.txt

@@ -0,0 +1,76 @@
+LICENSE
+README.md
+pyproject.toml
+setup.py
+src/abstract_ai_test/__init__.py
+src/abstract_ai_test/setup.py
+src/abstract_ai_test/src/__init__.py
+src/abstract_ai_test/src/api_calls.py
+src/abstract_ai_test/src/data_handler.py
+src/abstract_ai_test/src/endpoints.py
+src/abstract_ai_test/src/main.py
+src/abstract_ai_test/src/message_aggregator.py
+src/abstract_ai_test/src/prompts.py
+src/abstract_ai_test/src/response_handling.py
+src/abstract_ai_test/src/tokenization.py
+src/abstract_api_test/__init__.py
+src/abstract_api_test/setup.py
+src/abstract_api_test/src/__init__.py
+src/abstract_api_test/src/main.py
+src/abstract_audio_test/__init__.py
+src/abstract_audio_test/setup.py
+src/abstract_audio_test/src/__init__.py
+src/abstract_audio_test/src/main.py
+src/abstract_authority_replica_test/__init__.py
+src/abstract_authority_replica_test/setup.py
+src/abstract_authority_replica_test/src/__init__.py
+src/abstract_authority_replica_test/src/main.py
+src/abstract_authority_test/__init__.py
+src/abstract_authority_test/setup.py
+src/abstract_authority_test/src/__init__.py
+src/abstract_authority_test/src/main.py
+src/abstract_crypto_test/__init__.py
+src/abstract_crypto_test/setup.py
+src/abstract_crypto_test/src/__init__.py
+src/abstract_crypto_test/src/main.py
+src/abstract_gui_test/__init__.py
+src/abstract_gui_test/setup.py
+src/abstract_gui_test/src/__init__.py
+src/abstract_gui_test/src/main.py
+src/abstract_images_test/__init__.py
+src/abstract_images_test/setup.py
+src/abstract_images_test/src/__init__.py
+src/abstract_images_test/src/main.py
+src/abstract_modules_test/__init__.py
+src/abstract_modules_test/setup.py
+src/abstract_modules_test/src/__init__.py
+src/abstract_modules_test/src/main.py
+src/abstract_package_test.egg-info/PKG-INFO
+src/abstract_package_test.egg-info/SOURCES.txt
+src/abstract_package_test.egg-info/dependency_links.txt
+src/abstract_package_test.egg-info/entry_points.txt
+src/abstract_package_test.egg-info/top_level.txt
+src/abstract_paths_test/__init__.py
+src/abstract_paths_test/setup.py
+src/abstract_paths_test/src/__init__.py
+src/abstract_paths_test/src/main.py
+src/abstract_security_test/__init__.py
+src/abstract_security_test/setup.py
+src/abstract_security_test/src/__init__.py
+src/abstract_security_test/src/main.py
+src/abstract_threading_test/__init__.py
+src/abstract_threading_test/setup.py
+src/abstract_threading_test/src/__init__.py
+src/abstract_threading_test/src/main.py
+src/abstract_utilities_test/__init__.py
+src/abstract_utilities_test/setup.py
+src/abstract_utilities_test/src/__init__.py
+src/abstract_utilities_test/src/main.py
+src/abstract_web_aggregation_test/__init__.py
+src/abstract_web_aggregation_test/setup.py
+src/abstract_web_aggregation_test/src/__init__.py
+src/abstract_web_aggregation_test/src/main.py
+src/abstract_workstation_test/__init__.py
+src/abstract_workstation_test/setup.py
+src/abstract_workstation_test/src/__init__.py
+src/abstract_workstation_test/src/main.py

EGG-INFO/dependency_links.txt

@@ -0,0 +1 @@
+

EGG-INFO/entry_points.txt

@@ -0,0 +1,16 @@
+[console_scripts]
+abstract_ai_test = abstract_ai_test.main:main
+abstract_api_test = abstract_api_test.main:main
+abstract_audio_test = abstract_audio_test.main:main
+abstract_authority_replica_test = abstract_authority_replica_test.main:main
+abstract_authority_test = abstract_authority_test.main:main
+abstract_crypto_test = abstract_crypto_test.main:main
+abstract_gui_test = abstract_gui_test.main:main
+abstract_images_test = abstract_images_test.main:main
+abstract_modules_test = abstract_modules_test.main:main
+abstract_paths_test = abstract_paths_test.main:main
+abstract_security_test = abstract_security_test.main:main
+abstract_threading_test = abstract_threading_test.main:main
+abstract_utilities_test = abstract_utilities_test.main:main
+abstract_web_aggregation_test = abstract_web_aggregation_test.main:main
+abstract_workstation_test = abstract_workstation_test.main:main

EGG-INFO/not-zip-safe

@@ -0,0 +1 @@
+

EGG-INFO/top_level.txt

@@ -0,0 +1,15 @@
+abstract_ai_test
+abstract_api_test
+abstract_audio_test
+abstract_authority_replica_test
+abstract_authority_test
+abstract_crypto_test
+abstract_gui_test
+abstract_images_test
+abstract_modules_test
+abstract_paths_test
+abstract_security_test
+abstract_threading_test
+abstract_utilities_test
+abstract_web_aggregation_test
+abstract_workstation_test

abstract_ai_test/setup.py

@@ -0,0 +1,37 @@
+# This is the setup.py for module abstract_ai_test
+from setuptools import setup, find_packages
+from time import time
+import setuptools
+
+with open("README.md", "r", encoding="utf-8") as fh:
+    long_description = fh.read()
+
+setuptools.setup(
+    name='abstract_ai_test',
+    version='0.0.2',
+    author='putkoff',
+    author_email='partners@abstractendeavors.com',
+    description='abstract_ai_test is a Python package.',
+    long_description=long_description,
+    long_description_content_type='text/markdown',
+    url='https://github.com/AbstractEndeavors/abstract_package_test/abstract_ai_test',
+    packages=find_packages(where="src"),
+    classifiers=[
+        'Development Status :: 3 - Alpha',
+        'Intended Audience :: Developers',
+        'License :: OSI Approved :: MIT License',
+        'Programming Language :: Python :: 3',
+        'Programming Language :: Python :: 3.11',
+        "Operating System :: OS Independent",
+    ],
+    package_dir={"": "src"},
+    python_requires=">=3.6",
+    install_requires=[
+        # Add your project's requirements here, e.g.,
+        # 'numpy>=1.22.0',
+        # 'pandas>=1.3.0',
+    ],
+    entry_points={
+        'console_scripts': ["abstract_ai_test=abstract_ai_test.main:main"]
+    },
+)

abstract_ai_test/src/api_calls.py

@@ -0,0 +1,72 @@
+import os
+import json
+import requests
+import openai
+from abstract_security.envy_it import get_openai_key, getAPIkey
+from abstract_utilitites.time_utils import time_stamp,get_time_stamp,date
+from .tokenize import count_tokens, check_token_size
+from .prompt import default_prompt,create_prompt,default_tokens
+def headers():
+    """
+    Returns the headers for the API request.
+
+    Returns:
+        dict: The headers containing the 'Content-Type' and 'Authorization' information.
+    """
+    return {'Content-Type': 'application/json', 'Authorization': f'Bearer {getAPIkey()}'}
+
+
+def hard_request(max_tokens, prompt):
+    """
+    Sends a hard request to the OpenAI API using the provided parameters.
+
+    Args:
+        max_tokens (int): The maximum number of tokens for the completion.
+        prompt (str): The prompt for the API request.
+
+    Returns:
+        dict: The response received from the OpenAI API.
+    """
+    response = openai.Completion.create(
+        engine="text-davinci-002",
+        prompt=prompt,
+        max_tokens=max_tokens,
+        temperature=0.5,
+        top_p=1,
+        frequency_penalty=0,
+        presence_penalty=0
+    )
+    return response
+
+
+def quick_request(prompt: str = default_prompt(), max_tokens: int = default_tokens()):
+    """
+    Sends a quick request to the OpenAI API using the provided parameters and prints the result.
+
+    Args:
+        prompt (str, optional): The prompt for the API request. Defaults to the default_prompt().
+        max_tokens (int, optional): The maximum number of tokens for the completion. Defaults to default_tokens().
+
+    Returns:
+        None
+    """
+    print(json.dumps(hard_request(max_tokens, prompt).choices[0].text.strip(), indent=4))
+
+
+def raw_data(prompt: str = default_prompt(), js: dict = {}, endpoint: str = get_default_endpoint()):
+    """
+    Sends a raw data request to the specified endpoint with the provided parameters.
+
+    Args:
+        prompt (str, optional): The prompt for the API request. Defaults to default_prompt().
+        js (dict, optional): The JSON dictionary containing the request data. Defaults to an empty dictionary.
+        endpoint (str, optional): The endpoint for the API request. Defaults to get_default_endpoint().
+
+    Returns:
+        dict: The response received from the API request.
+    """
+    if 'prompt' not in js:
+        js['prompt'] = prompt
+    message_tokens = sum([len(js['prompt']) for message in js['prompt']])
+    js['max_tokens'] = get_default_tokens() - 10 - (int(message_tokens) - int(check_token_size(create_prompt(js), int(message_tokens))))
+    return save_response(js, requests.post(endpoint, json=create_prompt(js), headers=headers()))

abstract_ai_test/src/data_handler.py

@@ -0,0 +1,80 @@
+from endpoints import *
+from prompts import *
+def send_chunks(prompt: str = default_prompt(), content: str = '', model: str = default_model(),
+                endpoint: str = default_endpoint(), max_tokens: int = default_tokens(), title: str = 'current'):
+    """
+    Sends the content in chunks to the specified endpoint using the specified model and returns the responses.
+
+    Args:
+        prompt (str, optional): The prompt for the API request. Defaults to default_prompt().
+        content (str): The content to be sent in chunks.
+        model (str, optional): The model to use for the API request. Defaults to default_model().
+        endpoint (str, optional): The endpoint for the API request. Defaults to default_endpoint().
+        max_tokens (int, optional): The maximum number of tokens for each chunk. Defaults to default_tokens().
+        title (str, optional): The title of the data set. Defaults to 'current'.
+
+    Returns:
+        list: A list of dictionaries containing the responses for each chunk. Each dictionary has 'notation'
+              and 'target_response' keys.
+    """
+    content_chunks = re.findall('.{1,%s}' % (max_tokens // 2), content)
+    responses = []
+    for k, chunk in enumerate(content_chunks):
+        chunk_prompt = f"{prompt}, this is part {k + 1} of {len(content_chunks)} for the data set {title}.:\n{chunk}"
+        response = requests.post(endpoint, json=create_prompt({}, model=model, prompt=chunk_prompt,
+                                                               max_tokens=max_tokens, endpoint=endpoint),
+                                 headers=headers())
+        generated_text = response['choices'][0]['text'].strip()
+        try:
+            response_json = json.loads(generated_text)
+            notation = response_json["notation"]
+            target_response = response_json["target_response"]
+            responses.append({"notation": notation, "target_response": target_response})
+        except json.JSONDecodeError:
+            print("Error parsing response as JSON")
+    return responses
+
+
+def create_chunks(content, max_chunk_size):
+    """
+    Creates chunks of content based on the specified maximum chunk size.
+
+    Args:
+        content (str): The content to be split into chunks.
+        max_chunk_size (int): The maximum size of each chunk.
+
+    Returns:
+        list: A list of chunks where each chunk has a size less than or equal to the maximum chunk size.
+    """
+    words = content.split()
+    chunks = []
+    current_chunk = []
+
+    for word in words:
+        if len(' '.join(current_chunk)) + len(word) > max_chunk_size:
+            chunks.append(' '.join(current_chunk))
+            current_chunk = []
+        current_chunk.append(word)
+
+    chunks.append(' '.join(current_chunk))
+
+    return chunks
+
+
+def chunk_size(user_input=None):
+    """
+    Determines the appropriate chunk size for the user input content.
+
+    Args:
+        user_input (str): The user input content.
+
+    Returns:
+        int: The calculated maximum chunk size for the content.
+    """
+    initial_max_chunk_size = len(user_input)
+    content_chunks = create_chunks(user_input, initial_max_chunk_size)
+    max_chunk_size = calculate_max_chunk_size(user_input, len(content_chunks), selected_model)
+    if max_chunk_size != initial_max_chunk_size:
+        content_chunks = create_chunks(content, max_chunk_size)
+
+    return max_chunk_size

abstract_ai_test/src/endpoints.py

@@ -0,0 +1,110 @@
+from abstract_utilities.json_utils import invert_json
+from abstract_utilities.global_utils import change_glob, get_globes, if_none_default
+def get_token_js():
+    """
+    Returns the JSON dictionary containing token information and endpoints.
+
+    Returns:
+        dict: The JSON dictionary containing token information and endpoints.
+    """
+    return {
+        "token_info": {
+            "8192": ['gpt-4', 'gpt-4-0314'],
+            "32768": ['gpt-4-32k', 'gpt-4-32k-0314'],
+            "4097": ['gpt-3.5-turbo', 'gpt-3.5-turbo-0301', 'text-davinci-003', 'text-davinci-002'],
+            "8001": ["code-davinci-002", "code-davinci-001"],
+            "2048": ['code-cushman-002', 'code-cushman-001'],
+            "2049": ['davinci', 'curie', 'babbage', 'ada', 'text-curie-001', 'text-babbage-001', 'text-ada-001']
+        },
+        "endpoints": {
+            'https://api.openai.com/v1/chat/completions': [
+                "gpt-4", "gpt-4-0314", "gpt-4-32k", "gpt-4-32k-0314", "gpt-3.5-turbo", "gpt-3.5-turbo-0301"],
+            'https://api.openai.com/v1/completions': [
+                "text-davinci-003", "text-davinci-002", "text-curie-001", "text-babbage-001", "text-ada-001"],
+            'https://api.openai.com/v1/edits': [
+                "text-davinci-edit-001", "code-davinci-edit-001"],
+            'https://api.openai.com/v1/audio/transcriptions': ['whisper-1'],
+            'https://api.openai.com/v1/audio/translations': ['whisper-1'],
+            'https://api.openai.com/v1/fine-tunes': [
+                "davinci", "curie", "babbage", "ada"],
+            'https://api.openai.com/v1/embeddings': [
+                "text-embedding-ada-002", "text-search-ada-doc-001"],
+            'https://api.openai.com/v1/moderations': [
+                "text-moderation-stable", "text-moderation-latest"]
+        }
+    }
+
+
+def get_model_info():
+    """
+    Retrieves the inverted JSON dictionary of model information.
+
+    Returns:
+        dict: The inverted JSON dictionary where the keys are model names and the values are token numbers.
+    """
+    return invert_json(get_token_js()["endpoints"])
+
+
+def get_endpoint_info():
+    """
+    Retrieves the JSON dictionary containing endpoint information.
+
+    Returns:
+        dict: The JSON dictionary where the keys are endpoints and the values are lists of models.
+    """
+    return get_token_js()["endpoints"]
+
+
+def get_token_info():
+    """
+    Retrieves the inverted JSON dictionary of token information.
+
+    Returns:
+        dict: The inverted JSON dictionary where the keys are token numbers and the values are lists of models.
+    """
+    return invert_json(get_token_js()["token_info"])
+
+
+def default_endpoint():
+    """
+    Returns the default endpoint based on the 'endpoint_selection' setting.
+
+    Returns:
+        str: The default endpoint.
+    """
+    return if_none_default(st='endpoint_selection', default=list(get_endpoint_info().keys())[0])
+
+
+def default_model():
+    """
+    Returns the default model based on the 'model_selection' setting.
+
+    Returns:
+        str: The default model.
+    """
+    return if_none_default(st='model_selection', default=list(get_endpoint_info()[default_endpoint()])[0])
+
+
+def default_tokens():
+    """
+    Returns the default number of tokens based on the 'token_selection' setting.
+
+    Returns:
+        int: The default number of tokens.
+    """
+    return if_none_default(st='token_selection', default=get_token_info()[default_model()])
+
+
+def get_defaults(endpoint=default_endpoint(), model=default_model(), tokens=default_tokens()):
+    """
+    Returns a dictionary containing the default values for endpoint, model, and tokens.
+
+    Args:
+        endpoint (str, optional): The default endpoint. Defaults to default_endpoint().
+        model (str, optional): The default model. Defaults to default_model().
+        tokens (int, optional): The default number of tokens. Defaults to default_tokens().
+
+    Returns:
+        dict: A dictionary containing the default values for endpoint, model, and tokens.
+    """
+    return {"endpoint": endpoint, "model": model, "tokens": tokens}

abstract_ai_test/src/main.py

@@ -0,0 +1,35 @@
+import os
+import importlib.util
+
+excluded_files = ['__pycache__', 'main.py', '__init__.py']
+excluded_directories = ['__pycache__']
+
+def import_module_from_file(file_path):
+    module_name = os.path.splitext(os.path.basename(file_path))[0]
+    spec = importlib.util.spec_from_file_location(module_name, file_path)
+    module = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(module)
+    return module
+
+def get_filtered_files(directory):
+    modules = []
+    for item in os.listdir(directory):
+        item_path = os.path.join(directory, item)
+        if os.path.isfile(item_path) and item not in excluded_files:
+            if item_path.endswith('.py'):
+                modules.append(import_module_from_file(item_path))
+        elif os.path.isdir(item_path) and item not in excluded_directories:
+            modules.extend(get_filtered_files(item_path))
+    return modules
+
+def main():
+    print("Hello, this is abstract_ai_test.")
+    # You can import and use other modules or functions of abstract_ai_test here.
+    script_path = os.path.abspath(__file__)
+    directory_path = os.path.dirname(script_path)
+
+    filtered_modules = get_filtered_files(directory_path)
+
+if __name__ == "__main__":
+    # Get the absolute directory path of the current script file
+    main()

abstract_ai_test/src/message_aggregator.py

@@ -0,0 +1,148 @@
+import os
+import json
+from datetime import datetime
+import PySimpleGUI
+from functions import *
+from simple_gui_templates import *
+import PySimpleGUI as sg
+
+
+def get_timestamp(date_str, military_time_str):
+    """
+    Converts a date string and military time string to a timestamp.
+
+    Args:
+        date_str (str): The date string in the format 'YYYY-MM-DD'.
+        military_time_str (str): The military time string in the format 'HH:MM'.
+
+    Returns:
+        int: The timestamp corresponding to the date and time.
+    """
+    date_time_str = f"{date_str} {military_time_str}"
+    date_time_obj = datetime.strptime(date_time_str, '%Y-%m-%d %H:%M')
+    timestamp = int(date_time_obj.timestamp())
+    return timestamp
+
+
+def file_creation_time(file_path):
+    """
+    Retrieves the creation timestamp of a file.
+
+    Args:
+        file_path (str): The path to the file.
+
+    Returns:
+        float: The creation timestamp of the file.
+    """
+    creation_timestamp = os.path.getctime(file_path)
+    return creation_timestamp
+
+
+def find_keys(data, target_keys):
+    """
+    Finds the values associated with the specified target keys in a nested dictionary or list.
+
+    Args:
+        data (dict or list): The nested dictionary or list to search within.
+        target_keys (list): The list of keys to search for.
+
+    Returns:
+        list: A list of values associated with the target keys.
+    """
+    values = []
+    if isinstance(data, dict):
+        for key, value in data.items():
+            if key in target_keys:
+                values.append(value)
+            values.extend(find_keys(value, target_keys))
+    elif isinstance(data, list):
+        for item in data:
+            values.extend(find_keys(item, target_keys))
+    return values
+
+
+def print_it(st):
+    """
+    Prints the input string and returns it.
+
+    Args:
+        st (str): The string to be printed.
+
+    Returns:
+        str: The input string.
+    """
+    print(st)
+    return st
+
+
+def aggregate_conversations(directory):
+    """
+    Aggregates conversations from JSON files in the specified directory.
+
+    Args:
+        directory (str): The directory containing the JSON files.
+
+    Returns:
+        list: A list of aggregated conversations.
+    """
+    json_files, lsAll = [], []
+    for root, _, files in os.walk(directory):
+        for file in files:
+            if file.endswith(".json"):
+                file = os.path.join(root, file)
+                json_files.append((file_creation_time(file), file))
+    sorted_json_files = sorted(json_files, key=lambda x: x[0])
+    aggregated_conversations = []
+    chat_log_file = open("chat_log.txt", "w")
+    model = 'gpt'
+    for file in sorted_json_files:
+        with open(file[1], "r") as f:
+            data = json.load(f)
+            relevant_values = find_keys(data, ['messages', 'prompt', 'content'])
+            for i, value in enumerate(relevant_values):
+                while type(value) is list:
+                    value = value[0]
+                if type(value) is dict:
+                    if 'model' in value:
+                        model = value['model']
+                    if 'prompt' in value:
+                        lsAll.append({print_it("user"): print_it(value["prompt"])})
+                    if 'content' in value:
+                        lsAll.append({print_it(model): print_it(value['content'])})
+                print(lsAll)
+    chat_log_file.close()
+    return aggregated_conversations
+
+
+def browser():
+    """
+    Displays a directory browser window and returns the selected directory.
+
+    Returns:
+        str: The selected directory.
+    """
+    window = sg.Window('directory_browser', [
+        [sg.Input('', key="selection"), sg.FolderBrowse("Select File", key="-FOLDER_SELECT-", initial_folder="/home/bigrugz/Documents", target="-FOLDER_SELECT-", enable_events=True), 
+        sg.Button("select", key="-GRAB_FILE-", enable_events=True), sg.Button("EXIT", key="-EXIT-")]], resizable=True, finalize=True)
+    while True:
+        event, values = window.read()
+        if event == '-GRAB_FILE-':
+            window.close()
+            break
+    return values["selection"]
+
+
+def get_responses():
+    """
+    Retrieves the aggregated conversations from JSON files.
+
+    If the 'response_data' directory does not exist in the current working directory, prompts the user to select a directory
+    containing the JSON files. Otherwise, uses the 'response_data' directory.
+
+    Returns:
+        None
+    """
+    if "response_data" not in os.listdir(os.getcwd()):
+        aggregate_conversations(browser())
+    else:
+        aggregate_conversations("response_data")