randomcode 0.1.0__py3-none-any.whl

randomcode/litellm.py

@@ -0,0 +1,30 @@
+from typing import TYPE_CHECKING, Any
+
+from langchain._api import create_importer
+
+if TYPE_CHECKING:
+    from langchain_community.chat_models.litellm import (
+        ChatLiteLLM,
+        ChatLiteLLMException,
+    )
+
+# Create a way to dynamically look up deprecated imports.
+# Used to consolidate logic for raising deprecation warnings and
+# handling optional imports.
+DEPRECATED_LOOKUP = {
+    "ChatLiteLLM": "langchain_community.chat_models.litellm",
+    "ChatLiteLLMException": "langchain_community.chat_models.litellm",
+}
+
+_import_attribute = create_importer(__package__, deprecated_lookups=DEPRECATED_LOOKUP)
+
+
+def __getattr__(name: str) -> Any:
+    """Look up attributes dynamically."""
+    return _import_attribute(name)
+
+
+__all__ = [
+    "ChatLiteLLM",
+    "ChatLiteLLMException",
+]

randomcode/meta.py

@@ -0,0 +1,25 @@
+from typing import TYPE_CHECKING, Any
+
+from langchain._api import create_importer
+
+if TYPE_CHECKING:
+    from langchain_community.chat_models.meta import convert_messages_to_prompt_llama
+
+# Create a way to dynamically look up deprecated imports.
+# Used to consolidate logic for raising deprecation warnings and
+# handling optional imports.
+DEPRECATED_LOOKUP = {
+    "convert_messages_to_prompt_llama": "langchain_community.chat_models.meta",
+}
+
+_import_attribute = create_importer(__package__, deprecated_lookups=DEPRECATED_LOOKUP)
+
+
+def __getattr__(name: str) -> Any:
+    """Look up attributes dynamically."""
+    return _import_attribute(name)
+
+
+__all__ = [
+    "convert_messages_to_prompt_llama",
+]

randomcode/minimax.py

@@ -0,0 +1,23 @@
+from typing import TYPE_CHECKING, Any
+
+from langchain._api import create_importer
+
+if TYPE_CHECKING:
+    from langchain_community.chat_models.minimax import MiniMaxChat
+
+# Create a way to dynamically look up deprecated imports.
+# Used to consolidate logic for raising deprecation warnings and
+# handling optional imports.
+DEPRECATED_LOOKUP = {"MiniMaxChat": "langchain_community.chat_models.minimax"}
+
+_import_attribute = create_importer(__package__, deprecated_lookups=DEPRECATED_LOOKUP)
+
+
+def __getattr__(name: str) -> Any:
+    """Look up attributes dynamically."""
+    return _import_attribute(name)
+
+
+__all__ = [
+    "MiniMaxChat",
+]

randomcode/mlflow.py

@@ -0,0 +1,23 @@
+from typing import TYPE_CHECKING, Any
+
+from langchain._api import create_importer
+
+if TYPE_CHECKING:
+    from langchain_community.chat_models.mlflow import ChatMlflow
+
+# Create a way to dynamically look up deprecated imports.
+# Used to consolidate logic for raising deprecation warnings and
+# handling optional imports.
+DEPRECATED_LOOKUP = {"ChatMlflow": "langchain_community.chat_models.mlflow"}
+
+_import_attribute = create_importer(__package__, deprecated_lookups=DEPRECATED_LOOKUP)
+
+
+def __getattr__(name: str) -> Any:
+    """Look up attributes dynamically."""
+    return _import_attribute(name)
+
+
+__all__ = [
+    "ChatMlflow",
+]

randomcode/mlflow_ai_gateway.py

@@ -0,0 +1,30 @@
+from typing import TYPE_CHECKING, Any
+
+from langchain._api import create_importer
+
+if TYPE_CHECKING:
+    from langchain_community.chat_models.mlflow_ai_gateway import (
+        ChatMLflowAIGateway,
+        ChatParams,
+    )
+
+# Create a way to dynamically look up deprecated imports.
+# Used to consolidate logic for raising deprecation warnings and
+# handling optional imports.
+DEPRECATED_LOOKUP = {
+    "ChatMLflowAIGateway": "langchain_community.chat_models.mlflow_ai_gateway",
+    "ChatParams": "langchain_community.chat_models.mlflow_ai_gateway",
+}
+
+_import_attribute = create_importer(__package__, deprecated_lookups=DEPRECATED_LOOKUP)
+
+
+def __getattr__(name: str) -> Any:
+    """Look up attributes dynamically."""
+    return _import_attribute(name)
+
+
+__all__ = [
+    "ChatMLflowAIGateway",
+    "ChatParams",
+]

randomcode/ollama.py

@@ -0,0 +1,23 @@
+from typing import TYPE_CHECKING, Any
+
+from langchain._api import create_importer
+
+if TYPE_CHECKING:
+    from langchain_community.chat_models.ollama import ChatOllama
+
+# Create a way to dynamically look up deprecated imports.
+# Used to consolidate logic for raising deprecation warnings and
+# handling optional imports.
+DEPRECATED_LOOKUP = {"ChatOllama": "langchain_community.chat_models.ollama"}
+
+_import_attribute = create_importer(__package__, deprecated_lookups=DEPRECATED_LOOKUP)
+
+
+def __getattr__(name: str) -> Any:
+    """Look up attributes dynamically."""
+    return _import_attribute(name)
+
+
+__all__ = [
+    "ChatOllama",
+]

randomcode/openai.py

@@ -0,0 +1,23 @@
+from typing import TYPE_CHECKING, Any
+
+from langchain._api import create_importer
+
+if TYPE_CHECKING:
+    from langchain_community.chat_models.openai import ChatOpenAI
+
+# Create a way to dynamically look up deprecated imports.
+# Used to consolidate logic for raising deprecation warnings and
+# handling optional imports.
+DEPRECATED_LOOKUP = {"ChatOpenAI": "langchain_community.chat_models.openai"}
+
+_import_attribute = create_importer(__package__, deprecated_lookups=DEPRECATED_LOOKUP)
+
+
+def __getattr__(name: str) -> Any:
+    """Look up attributes dynamically."""
+    return _import_attribute(name)
+
+
+__all__ = [
+    "ChatOpenAI",
+]

randomcode/pai_eas_endpoint.py

@@ -0,0 +1,25 @@
+from typing import TYPE_CHECKING, Any
+
+from langchain._api import create_importer
+
+if TYPE_CHECKING:
+    from langchain_community.chat_models.pai_eas_endpoint import PaiEasChatEndpoint
+
+# Create a way to dynamically look up deprecated imports.
+# Used to consolidate logic for raising deprecation warnings and
+# handling optional imports.
+DEPRECATED_LOOKUP = {
+    "PaiEasChatEndpoint": "langchain_community.chat_models.pai_eas_endpoint",
+}
+
+_import_attribute = create_importer(__package__, deprecated_lookups=DEPRECATED_LOOKUP)
+
+
+def __getattr__(name: str) -> Any:
+    """Look up attributes dynamically."""
+    return _import_attribute(name)
+
+
+__all__ = [
+    "PaiEasChatEndpoint",
+]

randomcode/promptlayer_openai.py

@@ -0,0 +1,25 @@
+from typing import TYPE_CHECKING, Any
+
+from langchain._api import create_importer
+
+if TYPE_CHECKING:
+    from langchain_community.chat_models.promptlayer_openai import PromptLayerChatOpenAI
+
+# Create a way to dynamically look up deprecated imports.
+# Used to consolidate logic for raising deprecation warnings and
+# handling optional imports.
+DEPRECATED_LOOKUP = {
+    "PromptLayerChatOpenAI": "langchain_community.chat_models.promptlayer_openai",
+}
+
+_import_attribute = create_importer(__package__, deprecated_lookups=DEPRECATED_LOOKUP)
+
+
+def __getattr__(name: str) -> Any:
+    """Look up attributes dynamically."""
+    return _import_attribute(name)
+
+
+__all__ = [
+    "PromptLayerChatOpenAI",
+]

randomcode/python.py

@@ -0,0 +1,19 @@
+"""For backwards compatibility."""
+
+from typing import Any
+
+from langchain._api import create_importer
+
+# Code has been removed from the community package as well.
+# We'll proxy to community package, which will raise an appropriate exception,
+# but we'll not include this in __all__, so it won't be listed as importable.
+
+_importer = create_importer(
+    __package__,
+    deprecated_lookups={"PythonREPL": "langchain_community.utilities.python"},
+)
+
+
+def __getattr__(name: str) -> Any:
+    """Look up attributes dynamically."""
+    return _importer(name)

randomcode/requests.py

@@ -0,0 +1,35 @@
+"""DEPRECATED: Kept for backwards compatibility."""
+
+from typing import TYPE_CHECKING, Any
+
+from langchain._api import create_importer
+
+if TYPE_CHECKING:
+    from langchain_community.utilities import (
+        Requests,
+        RequestsWrapper,
+        TextRequestsWrapper,
+    )
+
+# Create a way to dynamically look up deprecated imports.
+# Used to consolidate logic for raising deprecation warnings and
+# handling optional imports.
+DEPRECATED_LOOKUP = {
+    "Requests": "langchain_community.utilities",
+    "RequestsWrapper": "langchain_community.utilities",
+    "TextRequestsWrapper": "langchain_community.utilities",
+}
+
+_import_attribute = create_importer(__package__, deprecated_lookups=DEPRECATED_LOOKUP)
+
+
+def __getattr__(name: str) -> Any:
+    """Look up attributes dynamically."""
+    return _import_attribute(name)
+
+
+__all__ = [
+    "Requests",
+    "RequestsWrapper",
+    "TextRequestsWrapper",
+]

randomcode/s1.py

@@ -0,0 +1,28 @@
+%Performing Union, Intersection and Complement Operations 
+
+clc;
+clear;
+
+u = input('Enter the membership values of First Fuzzy set: ');
+v = input('Enter the membership values of Second Fuzzy set: ');
+
+if length(u) ~= length(v)
+    error('Both fuzzy sets must have the same number');
+end
+
+w = max(u, v);
+p = min(u, v);
+q1 = 1 - u;
+q2 = 1 - v;
+
+disp('Union of Two Fuzzy sets:');
+disp(w);
+
+disp('Intersection of Two Fuzzy sets:');
+disp(p);
+
+disp('Complement of First Fuzzy set:');
+disp(q1);
+
+disp('Complement of Second Fuzzy set:');
+disp(q2);

randomcode/s10.py

@@ -0,0 +1,56 @@
+# Genetic Algorithm – II 
+
+import random
+
+weights = [2, 3, 4, 5]
+values = [6, 10, 12, 13]
+capacity = 8
+
+POP_SIZE = 6
+GENES = len(weights)
+GENERATIONS = 15
+MUT_RATE = 0.1
+
+population = [[random.randint(0, 1) for _ in range(GENES)]
+              for _ in range(POP_SIZE)]
+
+def fitness(chrom):
+    total_weight = 0
+    total_value = 0
+    for i in range(GENES):
+        if chrom[i] == 1:
+            total_weight += weights[i]
+            total_value += values[i]
+    if total_weight > capacity:
+        return 0
+    return total_value
+
+for gen in range(GENERATIONS):
+
+    fit_vals = [fitness(c) for c in population]
+    best_fit = max(fit_vals)
+    best_idx = fit_vals.index(best_fit)
+
+    print("Gen", gen+1,
+          "Best =", population[best_idx],
+          "Value =", best_fit)
+
+    new_pop = []
+
+    for _ in range(POP_SIZE):
+        a, b = random.sample(range(POP_SIZE), 2)
+        winner = population[a] if fit_vals[a] > fit_vals[b] else population[b]
+        new_pop.append(winner[:])
+
+    for i in range(0, POP_SIZE, 2):
+        if random.random() < 0.8:
+            cp = random.randint(1, GENES - 1)
+            new_pop[i][:cp], new_pop[i+1][:cp] = \
+                new_pop[i+1][:cp], new_pop[i][:cp]
+
+    for i in range(POP_SIZE):
+        for j in range(GENES):
+            if random.random() < MUT_RATE:
+                new_pop[i][j] ^= 1
+
+    population = new_pop

randomcode/s2.py

@@ -0,0 +1,49 @@
+%Implementation of De Morgan’s Law 
+
+clc;
+clear;
+
+u = input('Enter the membership values of first fuzzy set: ');
+v = input('Enter the membership values of second fuzzy set: ');
+
+if length(u) ~= length(v)
+    error('Both fuzzy sets must have the same number');
+end
+
+w = max(u, v);
+p = min(u, v);
+q1 = 1 - u;
+q2 = 1 - v;
+
+x1 = 1 - w;
+x2 = min(q1, q2);
+
+y1 = 1 - p;
+y2 = max(q1, q2);
+
+disp('Union of two fuzzy sets (max operation)');
+disp(w);
+
+disp('Intersection of two fuzzy sets (min operation)');
+disp(p);
+
+disp('Complement of first fuzzy set');
+disp(q1);
+
+disp('Complement of second fuzzy set');
+disp(q2);
+
+disp('De Morgan Law Verification');
+
+disp('1) Complement of Maximum = Minimum of Complements');
+disp('LHS:');
+disp(x1);
+disp('RHS:');
+disp(x2);
+
+disp('2) Complement of Minimum = Maximum of Complements');
+disp('LHS:');
+disp(y1);
+disp('RHS:');
+disp(y2);
+

randomcode/s3.py

@@ -0,0 +1,37 @@
+% Plotting Various Membership Functions 
+
+clc;
+clear;
+close all;
+
+figure;
+
+x = 0:1:10;
+y1 = trimf(x, [1 3 5]);
+
+subplot(3,1,1);
+plot(x, y1, 'LineWidth', 2);
+title('Triangular Membership Function');
+xlabel('x');
+ylabel('Membership Value');
+grid on;
+
+x = 0:1:10;
+y2 = trapmf(x, [1 3 5 7]);
+
+subplot(3,1,2);
+plot(x, y2, 'LineWidth', 2);
+title('Trapezoidal Membership Function');
+xlabel('x');
+ylabel('Membership Value');
+grid on;
+
+x = 0:0.2:10;
+y3 = gbellmf(x, [3 5 7]);
+
+subplot(3,1,3);
+plot(x, y3, 'LineWidth', 2);
+title('Bell Shaped Membership Function');
+xlabel('x');
+ylabel('Membership Value');
+grid on;

randomcode/s4.py

@@ -0,0 +1,19 @@
+% Using Fuzzy toolbox to model tips value
+
+Quality: {not good, satisfying, delightful}
+Service: {poor, average, good}
+
+
+Type fuzzy in MATLAB to open FIS Editor.
+
+Add two inputs:
+Quality: not_good, satisfied, delicious
+Service: poor, average, good
+
+Add one output:
+
+Tip: less, medium, high (Range 10–100)
+Assign triangular (trimf) membership functions for all variables.
+Create rules in Rules Editor.
+View results in Rule Viewer and test the system.
+Save and exit.

randomcode/s5.py

@@ -0,0 +1,28 @@
+% Implementation of Fuzzy Inference System
+
+# INPUTS 
+
+Temperature: {Freeze, Cool, Warm and Hot}
+Cloud Cover: {Sunny, Partly Cloudy and Overcast}
+
+#rules
+
+Sunny (Cover) and Warm (Temp) -> Fast (Speed) 
+Cloudy (Cover) and Cool (Temp) -> Slow (Speed)
+
+
+Type fuzzy in MATLAB.
+
+Add inputs:
+Temperature: Freezing, Cool, Warm, Hot
+Cloud Cover: Sunny, Partly Cloudy, Overcast
+
+Add output:
+Speed: Slow, Fast
+
+Assign appropriate trimf/trapmf membership functions.
+Add rules:
+
+Sunny & Warm → Fast
+Overcast & Cool → Slow
+View in Rule Viewer and save.

randomcode/s6.py

@@ -0,0 +1,44 @@
+% Simple Fuzzy Set Operations 
+
+clc;
+clear;
+
+a = input('Enter the fuzzy set A: ');
+b = input('Enter the fuzzy set B: ');
+
+if length(a) ~= length(b)
+    error('Both fuzzy sets must have the same number of elements');
+end
+
+c = a + b;
+d = a .* b;
+
+as = c - d;
+e = 1 - b;
+ad = a .* e;
+
+f = a - b;
+
+bs = min(1, c);
+bd = max(0, f);
+
+g = c - 1;
+bp = max(0, g);
+
+disp('The algebraic sum:');
+disp(as);
+
+disp('The algebraic difference:');
+disp(ad);
+
+disp('The algebraic product:');
+disp(d);
+
+disp('The bounded sum:');
+disp(bs);
+
+disp('The bounded difference:');
+disp(bd);
+
+disp('The bounded product:');
+disp(bp);

randomcode/s7.py

@@ -0,0 +1,46 @@
+% Generation of ANDNOT function using McCulloch-Pitts neural net 
+
+clc;
+clear;
+
+disp('Enter weights');
+w1 = input('w1 = ');
+w2 = input('w2 = ');
+
+disp('Enter threshold');
+theta = input('theta = ');
+
+x1 = [0 0 1 1];
+x2 = [0 1 0 1];
+target = [0 0 1 0];  
+
+while 1
+    zin = x1*w1 + x2*w2;
+    y = zeros(1,4);
+
+    for i = 1:4
+        if zin(i) >= theta
+            y(i) = 1;
+        else
+            y(i) = 0;
+        end
+    end
+
+    disp('Output = ');
+    disp(y);
+
+    if isequal(y, target)
+        break;
+    else
+        disp('Wrong weights. Enter again.');
+        w1 = input('w1 = ');
+        w2 = input('w2 = ');
+        theta = input('theta = ');
+    end
+end
+
+disp('McCulloch Pitts Net for ANDNOT');
+disp('Weights:');
+disp([w1 w2]);
+disp('Threshold:');
+disp(theta);

randomcode/s8.py

@@ -0,0 +1,53 @@
+% Perceptron neural network 
+
+clc;
+clear;
+
+x = [ 1  1 -1 -1;
+      1 -1  1 -1 ];
+
+t = [1 -1 -1 -1];
+
+w = [0 0];    
+b = 0;      
+
+alpha = input('Enter learning rate = ');
+theta = input('Enter threshold = ');
+
+epoch = 0;
+
+while true
+    error_flag = 0;
+
+    for i = 1:4
+        yin = b + w * x(:,i);
+
+        if yin > theta
+            y = 1;
+        elseif yin < -theta
+            y = -1;
+        else
+            y = 0;
+        end
+
+        if y ~= t(i)
+            w = w + alpha * t(i) * x(:,i)';
+            b = b + alpha * t(i);
+            error_flag = 1;
+        end
+    end
+
+    epoch = epoch + 1;
+
+    if error_flag == 0
+        break;
+    end
+end
+
+disp('Perceptron for AND Function');
+disp('Final Weights:');
+disp(w);
+disp('Final Bias:');
+disp(b);
+disp('Epochs:');
+disp(epoch);