opsci-toolbox 0.0.7__py3-none-any.whl → 0.0.9__py3-none-any.whl

opsci_toolbox/helpers/sna.py

@@ -7,6 +7,515 @@ from opsci_toolbox.helpers.dataviz import generate_color_palette_with_colormap,
 from opsci_toolbox.helpers.common import scale_list
 import pandas as pd
 import math
+from collections import Counter
+from opsci_toolbox.helpers.dataviz import boxplot
+from fa2_modified import ForceAtlas2
+
+def group_nodes_by_values(dictionnary : dict) -> dict:
+    """
+    Group nodes by their values from a dictionary.
+
+    Args:
+        dictionnary (Dict[Any, Any]): A dictionary where keys are nodes and values are attributes 
+                                      or categories.
+
+    Returns:
+        Dict[Any, List[Any]]: A dictionary where each key is a unique value from the input dictionary,
+                              and the corresponding value is a list of nodes that have that value.
+
+    """
+    new_dict = {}
+    for node, comm in dictionnary.items():
+        if comm not in new_dict:
+            new_dict[comm] = []
+        new_dict[comm].append(node)
+    return new_dict
+
+def graph_key_metrics(G : nx.Graph) -> dict:
+    """
+    Calculate key metrics for a NetworkX graph.
+
+    Args:
+        G (nx.Graph): The NetworkX graph for which to calculate metrics.
+
+    Returns:
+        Dict[str, float]: A dictionary containing the following metrics:
+            - "nodes": Number of nodes in the graph.
+            - "edges": Number of edges in the graph.
+            - "density": Density of the graph.
+            - "average_degree": Average degree of nodes in the graph.
+            - "assortativity": Degree assortativity coefficient of the graph.
+            - "transitivity": Transitivity (global clustering coefficient) of the graph.
+    """
+    num_nodes = G.number_of_nodes()
+    num_edges = G.number_of_edges()
+    density = nx.density(G)
+    total_degree = sum(degree for _, degree in G.degree())
+    avg_degree = total_degree / num_nodes if num_nodes > 0 else 0
+    assortativity = nx.degree_assortativity_coefficient(G)
+    transitivity = nx.transitivity(G)
+    key_metrics = {
+        "nodes": num_nodes,
+        "edges" : num_edges,
+        "density" : density,
+        "average_degree" : avg_degree,
+        "assortativity" : assortativity,
+        "transitivity" : transitivity
+    }
+    return key_metrics
+
+def communities_metrics(G : nx.Graph, nodes_by_community : dict) -> dict:
+    """
+    Calculate various metrics for communities within a subgraph.
+
+    Args:
+        G (nx.Graph): The NetworkX graph containing the communities.
+        nodes_by_community (Dict[Any, List[Any]]): A dictionary where keys are community identifiers and
+                                                   values are lists of nodes in each community.
+
+    Returns:
+        Dict[Any, Dict[str, float]]: A dictionary where each key is a community identifier, and the value 
+                                     is another dictionary containing various metrics for that community.
+    """
+    communities_metrics = {}
+    for comm, nodes in nodes_by_community.items():
+        subgraph = G.subgraph(nodes)
+        num_nodes = subgraph.number_of_nodes()
+        num_edges = subgraph.number_of_edges()
+        density = nx.density(subgraph)
+        total_degree = sum(degree for _, degree in subgraph.degree())
+        avg_degree = total_degree / num_nodes if num_nodes > 0 else 0
+        assortativity = nx.degree_assortativity_coefficient(subgraph)
+        transitivity = nx.transitivity(subgraph)
+        communities_metrics[comm] = {
+            "nodes": num_nodes,
+            "edges": num_edges,
+            "density": density,
+            "average_degree": avg_degree,
+            "assortativity": assortativity,
+            "transitivity": transitivity,
+        }
+    return communities_metrics
+
+def remove_attributes(G : nx.Graph, attributes : list = ['degree_centrality', 'in_degree_centrality', 'out_degree_centrality', 'eigenvector_centrality', 'degree', 'in_degree', 'out_degree', 'composante', 'betweenness_centrality', 'viz']) -> nx.Graph:
+    """
+    Remove specified attributes from all nodes in a NetworkX graph.
+
+    Args:
+        G (nx.Graph): The NetworkX graph from which to remove node attributes.
+        attributes (List[str], optional): List of attribute names to remove from each node. 
+                                          Defaults to common graph attributes.
+
+    Returns:
+        nx.Graph: The graph with the specified attributes removed from each node.
+    """
+    for node, attrs in G.nodes(data=True):
+        for attr in attributes:
+            attrs.pop(attr, None)
+    return G
+
+def compute_modularity(G : nx.Graph, resolution : float =1, col_name : str = "modularity") -> dict:
+   """
+    Compute modularity of a graph using the Louvain method and assign community labels as node attributes.
+
+    Args:
+        G (nx.Graph): The input graph for which to compute modularity.
+        resolution (float, optional): The resolution parameter for the Louvain method. Default is 1.
+        col_name (str, optional): The name of the node attribute to store community labels. Default is "modularity".
+
+    Returns:
+        Dict[int, int]: A dictionary mapping each node to its community.
+   """
+   try : 
+      communities = nx.community.louvain_communities(G, resolution=resolution)
+      community_dict=transform_dict_of_nodes(communities)
+   except Exception as e:
+      pass
+      print(e)
+      community_dict = {node: 0 for node in G.nodes()}
+   nx.set_node_attributes(G, community_dict, col_name)
+   return community_dict
+
+def compute_degrees(G : nx.Graph, col_name : str = "degree") -> dict:
+   """ 
+   Compute the degrees of nodes in a graph and assign them as node attributes.
+
+    Args:
+        G (nx.Graph): The input graph for which to compute node degrees.
+        col_name (str, optional): The name of the node attribute to store degrees. Default is "degree".
+
+    Returns:
+        Dict[int, int]: A dictionary mapping each node to its degree.
+   """
+   try:
+      degree_dict = {node[0] : node[1] for node in list(G.degree())}      
+   except Exception as e:
+      pass
+      print(e)
+      degree_dict = {node: 0 for node in G.nodes()}
+   nx.set_node_attributes(G, degree_dict, col_name)
+   return degree_dict
+
+def compute_in_degrees(G: nx.Graph, col_name : str = "in_degree") -> dict:
+   """ 
+   Compute the in degrees of nodes in a graph and assign them as node attributes.
+
+    Args:
+        G (nx.Graph): The input graph for which to compute node in degrees.
+        col_name (str, optional): The name of the node attribute to store in degrees. Default is "in_degree".
+
+    Returns:
+        Dict[int, int]: A dictionary mapping each node to its degree.
+   """
+   try:
+      in_degree_dict = {node[0] : node[1] for node in list(G.in_degree())}
+   except Exception as e :
+      pass
+      print(e)
+      in_degree_dict = {node: 0 for node in G.nodes()}
+   nx.set_node_attributes(G, in_degree_dict, col_name)
+   return in_degree_dict
+
+def compute_out_degrees(G : nx.Graph, col_name : str = "out_degree") -> dict: 
+   """ 
+   Compute the out degrees of nodes in a graph and assign them as node attributes.
+
+    Args:
+        G (nx.Graph): The input graph for which to compute node out degrees.
+        col_name (str, optional): The name of the node attribute to store in degrees. Default is "out_degree".
+
+    Returns:
+        Dict[int, int]: A dictionary mapping each node to its degree.
+   """     
+   try:
+      out_degree_dict = {node[0] : node[1] for node in list(G.out_degree())}
+   except Exception as e:
+      pass
+      print(e)
+      out_degree_dict = {node: 0 for node in G.nodes()}
+   nx.set_node_attributes(G, out_degree_dict, col_name)
+   return out_degree_dict
+
+def compute_degree_centrality(G : nx.Graph, col_name : str = "degree_centrality") -> dict :
+   """
+   Computes and sets Degree centrality metric for the nodes in the network graph.
+   
+   Args:
+      network (nx.Graph): The network graph on which to compute centrality.
+   
+   Returns:
+      None
+   """
+   try:
+      degree_cent = nx.degree_centrality(G)
+      nx.set_node_attributes(G, degree_cent, col_name)
+      # print("Calcul de la centralité de degrés effectué")
+   except Exception as e:
+      pass
+      # print(e, "Calcul de la centralité de degrés impossible")
+      # Set a default value for degree centrality
+      degree_cent = {node: 0 for node in G.nodes()}
+      nx.set_node_attributes(G, degree_cent, col_name)
+   return degree_cent
+
+def compute_in_degree_centrality(G : nx.Graph, col_name : str = "in_degree_centrality") -> dict :
+   """
+   Computes and sets In Degree centrality metric for the nodes in the network graph.
+   
+   Args:
+      network (nx.Graph): The network graph on which to compute centrality.
+   
+   Returns:
+      None
+   """
+   try:
+      in_degree_cent = nx.in_degree_centrality(G)
+      nx.set_node_attributes(G, in_degree_cent, col_name)
+   except Exception as e:
+      pass
+      # Set a default value for degree centrality
+      in_degree_cent = {node: 0 for node in G.nodes()}
+      nx.set_node_attributes(G, in_degree_cent, col_name)
+   return in_degree_cent
+
+def compute_out_degree_centrality(G : nx.Graph, col_name : str = "out_degree_centrality") -> dict :
+   """
+   Computes and sets Out Degree centrality metric for the nodes in the network graph.
+   
+   Args:
+      network (nx.Graph): The network graph on which to compute centrality.
+   
+   Returns:
+      None
+   """
+   try:
+      out_degree_cent = nx.out_degree_centrality(G)
+      nx.set_node_attributes(G, out_degree_cent, col_name)
+   except Exception as e:
+      pass
+      # Set a default value for degree centrality
+      out_degree_cent = {node: 0 for node in G.nodes()}
+      nx.set_node_attributes(G, out_degree_cent, col_name)
+   return out_degree_cent
+      
+
+def compute_eigenvector_centrality(G : nx.Graph, col_name : str = "eigenvector_centrality") -> dict :
+   """
+    Computes and sets Eigenvector centrality metric for the nodes in the network graph.
+    
+    Args:
+        network (nx.Graph): The network graph on which to compute centrality.
+    
+    Returns:
+        None
+    """
+   ### CALCUL DE LA CENTRALITE DE VECTEUR PROPRE
+   try:
+      eigenvector_centrality = nx.eigenvector_centrality(G)
+      nx.set_node_attributes(G, eigenvector_centrality, col_name)
+      # print("Calcul de la centralité de vecteur propre effectué")
+   except Exception as e:
+      pass
+      # print(e, "Calcul de la centralité de vecteur propre impossible")
+      # Set a default value for centrality
+      eigenvector_centrality = {node: 0 for node in G.nodes()}
+      nx.set_node_attributes(G, eigenvector_centrality, col_name)
+   return eigenvector_centrality
+
+def compute_betweenness_centrality(G : nx.Graph, col_name : str = "betweenness_centrality") -> dict :
+   """
+   Computes and sets Betweeness centrality metric for the nodes in the network graph.
+   
+   Args:
+      network (nx.Graph): The network graph on which to compute centrality.
+   
+   Returns:
+      None
+   """
+   try:
+      betweenness_cent = nx.betweenness_centrality(G, k=None, normalized=True, weight='weight', endpoints=False, seed=None)
+      nx.set_node_attributes(G, betweenness_cent, col_name)
+      # print("Calcul de l'intermédiarité effectué")
+   except Exception as e:
+      pass
+      # print(e, "Calcul de l'intermédiarité impossible")
+      # Set a default value for betweenness centrality
+      betweenness_cent = {node: 0 for node in G.nodes()}
+      nx.set_node_attributes(G, betweenness_cent, col_name)
+   return betweenness_cent
+
+def calcul_composantes_connexes(G : nx.Graph, col_name : str = "composante") -> dict:
+   """
+   Calculate weakly connected components in a graph and assign component labels as node attributes.
+
+   Args:
+        G (nx.Graph): The input graph.
+        col_name (str, optional): The name of the node attribute to store component labels. Default is "composante".
+
+   Returns:
+        List[set]: A list of sets, each set containing nodes belonging to a weakly connected component.
+   """
+   composantes_connexes = sorted(nx.weakly_connected_components(G),
+                                  key=len, # clé de tri - len = longueur de la composante
+                                  reverse=True)
+    
+   composantes_dict = transform_dict_of_nodes(composantes_connexes)
+   nx.set_node_attributes(G, composantes_dict, col_name)
+   return composantes_connexes
+
+def filtrer_composante_principale(G: nx.Graph, composantes_connexes : dict) -> nx.Graph:
+   """
+    Filter the main component (largest weakly connected component) from a graph.
+
+    Args:
+        G (nx.Graph): The input graph.
+        composantes_connexes (Dict[int, set]): Dictionary mapping component indices to sets of nodes.
+
+    Returns:
+        nx.Graph: The largest weakly connected component as a subgraph of the original graph.
+   """
+   composante_principale = G.subgraph(composantes_connexes[0])
+   return composante_principale
+
+def select_mutual_relationships(G: nx.Graph)  -> set:
+   """
+    Select mutual relationships (edges) in a graph.
+
+    Args:
+        G (nx.Graph): The input graph.
+
+    Returns:
+        Set[Tuple[int, int]]: A set of tuples representing mutual edges.
+   """
+   mutual_edges = set()
+   for u, v in G.edges():
+      if G.has_edge(v, u):
+         mutual_edges.add((u, v))
+         mutual_edges.add((v, u))
+   return mutual_edges
+
+def select_top_nodes_by_metric(G: nx.Graph, metric : str = "degree_centrality", N : int =1000) -> nx.Graph:
+    """
+    Selects the top N nodes in the graph based on a specified node attribute (metric) and returns the subgraph of these nodes.
+
+    Args:
+        G (nx.Graph): The input graph.
+        metric (str, optional): The node attribute used to rank and select the top nodes. Default is "degree_centrality".
+        N (int, optional): The number of top nodes to select. Default is 1000.
+
+    Returns:
+        subgraph (Optional[nx.Graph]): A subgraph containing the top N nodes based on the specified metric. Returns None if the metric is not found.
+
+    """
+    if metric in G.nodes[list(G.nodes)[0]].keys():
+        metric_selection = select_attribute(G, metric)
+        sorted_nodes = sorted(dict(metric_selection).items(), key=lambda x: x[1], reverse=True)
+        top_N_nodes = [node for node, degree in sorted_nodes[:N]]
+        subgraph = G.subgraph(top_N_nodes)
+        return subgraph
+    else:
+        print(metric, "not found in nodes attribute")
+        return None
+    
+def select_attribute(G : nx.Graph, attribute : str) -> dict:
+    """
+    Extracts a specified attribute from each node in the graph and returns it as a dictionary.
+
+    Args:
+        G (nx.Graph): The input graph.
+        attribute (str): The node attribute to extract.
+
+    Returns:
+        attribute_dict (Dict): A dictionary where keys are node identifiers and values are the attribute values.
+    """
+    attribute_dict = {node[0] : node[1][attribute] for node in G.nodes(data=True)}
+    return attribute_dict
+
+def select_top_nodes_by_degrees(G: nx.Graph, degree_type : str = "degree", N : int = 1000) -> nx.Graph:
+    """
+    Selects the top N nodes from a graph based on their degree and returns a subgraph.
+
+    Args:
+      G : nx.Graph The input graph, which can be undirected or directed.
+      degree_type : str, optional, default="degree". The type of degree to consider for selection. Valid values are "degree", "in degree", and "out degree".
+      N : int, optional, default=1000. The number of top nodes to select based on degree.
+    Returns:
+       nx.Graph : A subgraph containing the top N nodes based on the specified degree type.
+    
+    Raises:
+      ValueError : If an invalid degree_type is provided.
+    """
+    if degree_type == "degree":
+        degree_selection = G.degree()
+    elif degree_type == "in degree":
+        degree_selection = G.in_degree()
+    elif degree_type == "out degree":
+        degree_selection = G.out_degree()
+    else:
+        raise ValueError("Invalid degree_type. Must be one of: 'degree', 'in degree', 'out degree'.")
+    
+    sorted_nodes_by_degree = sorted(dict(degree_selection).items(), key=lambda x: x[1], reverse=True)
+    top_N_nodes = [node for node, degree in sorted_nodes_by_degree[:N]]
+    subgraph = G.subgraph(top_N_nodes)
+
+    return subgraph
+
+
+def scale_size(G, size_attribute, min_node_size = 10, max_node_size = 100):
+    """
+    Scale the sizes of nodes in a graph based on a specified attribute.
+
+    Args:
+        G (nx.Graph): The graph containing nodes with attributes.
+        size_attribute (str): The node attribute to scale the sizes by.
+        min_node_size (int, optional): The minimum size to scale to. Default is 10.
+        max_node_size (int, optional): The maximum size to scale to. Default is 100.
+
+    Returns:
+        List[int]: A list of scaled node sizes.
+    """
+    sizes=[n[1].get(size_attribute,0) for n in G.nodes(data=True)]
+    scaled_sizes = scale_list(sizes, min_node_size, max_node_size)
+    return scaled_sizes
+
+def transform_dict_of_nodes(dict_of_nodes : dict) -> dict:
+   """
+   Dictionnary format transformation
+   Args:
+      dict_of_nodes (dict) : dictionnary returned by networkx
+   Returns:
+      transformed_dict (dict)
+
+   """
+   transformed_dict={}
+   for idx, nodes in enumerate(dict_of_nodes):
+      for node_id in nodes:
+         transformed_dict[node_id] = idx
+   return transformed_dict
+
+def layout_forceatlas(G: nx.Graph, dissuade_hubs: bool = True, edge_weight_influence: float = 1.0, scalingRatio: float = 5.0, gravity: float = 0.5, iterations: int = 200) -> dict:
+    """
+    Computes a ForceAtlas2 layout for a NetworkX graph.
+
+    Args:
+      G : nx.Graph
+         The input graph.
+      dissuade_hubs : bool, optional, default=True
+         Whether to apply the outbound attraction distribution, which dissuades hubs.
+      edge_weight_influence : float, optional, default=1.0
+         The influence of edge weights on the layout.
+      scalingRatio : float, optional, default=5.0
+         The scaling ratio for the layout.
+      gravity : float, optional, default=0.5
+         The gravity force applied to the layout.
+      iterations : int, optional, default=200
+         The number of iterations to run the layout algorithm.
+
+    Returns:
+      dict : a dictionary mapping node IDs to their positions in 2D space.
+    """
+    
+    forceatlas2 = ForceAtlas2(
+                        # Behavior alternatives
+                        outboundAttractionDistribution=dissuade_hubs,  # Dissuade hubs
+                        linLogMode=False,  # NOT IMPLEMENTED
+                        adjustSizes=False,  # Prevent overlap (NOT IMPLEMENTED)
+                        edgeWeightInfluence=edge_weight_influence,
+
+                        # Performance
+                        jitterTolerance=1.0,  # Tolerance
+                        barnesHutOptimize=True,
+                        barnesHutTheta=1.2,
+                        multiThreaded=False,  # NOT IMPLEMENTED
+
+                        # Tuning
+                        scalingRatio=scalingRatio,
+                        strongGravityMode=False,
+                        gravity=gravity,
+
+                        # Log
+                        verbose=True)
+
+    layout_positions = forceatlas2.forceatlas2_networkx_layout(G, pos=None, iterations=iterations)
+    return layout_positions
+
+def distribution(metric_dict : dict, metric_name : str) -> tuple:
+   """
+    Generate a distribution DataFrame and a boxplot for a given metric.
+
+    Args:
+        metric_dict (dict): Dictionary containing metric data, with keys as nodes and values as metric values.
+        metric_name (str): The name of the metric to be used as the column name in the DataFrame and plot titles.
+
+    Returns:
+        DataFrame containing the distribution of metric values.
+        Boxplot figure visualizing the distribution of the metric.
+   """
+   metric_count = Counter(metric_dict.values())
+   df = pd.DataFrame(list(metric_count.items()), columns=[metric_name, "nodes"]).sort_values(by="nodes", ascending=False)
+   fig =  boxplot(df, col_y = metric_name, title =f"{metric_name} - Nodes distribution", yaxis_title = metric_name)
+   return df, fig
+
 
 def create_collocations(lst_text : list, word_freq : int, coloc_freq : int, stop_words : list) -> tuple:
     """

opsci_toolbox/helpers/sql.py

@@ -0,0 +1,53 @@
+import mysql.connector
+import pandas as pd
+from mysql.connector import errorcode
+
+def connect_to_mysql_database(host: str = 'localhost', user: str = 'root', password: str = 'password', database: str = 'subs'):
+    """
+    Connect to a MySQL database.
+
+    Parameters:
+    - host (str): The host of the database. Default is 'localhost'.
+    - user (str): The username to use for connecting to the database. Default is 'root'.
+    - password (str): The password to use for connecting to the database. Default is 'password'.
+    - database (str): The name of the database to connect to. Default is 'subs'.
+
+    Returns:
+    - mysql.connector.connection.MySQLConnection: The connection object if connection is successful.
+    - None: If the connection fails.
+    """
+    try:
+        conn = mysql.connector.connect(
+            host=host,
+            user=user,
+            password=password,
+            database=database
+        )
+        return conn
+    except mysql.connector.Error as err:
+        if err.errno == errorcode.ER_ACCESS_DENIED_ERROR:
+            print("Something is wrong with your user name or password")
+        elif err.errno == errorcode.ER_BAD_DB_ERROR:
+            print("Database does not exist")
+        else:
+            print(err)
+        return None
+
+def execute_query(conn: mysql.connector.connection.MySQLConnection, query: str) -> pd.DataFrame:
+    """
+    Execute a SQL query and return the results as a pandas DataFrame.
+
+    Parameters:
+    - conn (mysql.connector.connection.MySQLConnection): The connection object to the database.
+    - query (str): The SQL query to be executed.
+
+    Returns:
+    - pd.DataFrame: A DataFrame containing the results of the query.
+    """
+    cursor = conn.cursor()
+    cursor.execute(query)
+    results = cursor.fetchall()
+    column_names = [i[0] for i in cursor.description]
+    df = pd.DataFrame(results, columns=column_names)
+    cursor.close()
+    return df

{opsci_toolbox-0.0.7.dist-info → opsci_toolbox-0.0.9.dist-info}/METADATA

@@ -1,33 +1,36 @@
 Metadata-Version: 2.1
 Name: opsci-toolbox
-Version: 0.0.7
+Version: 0.0.9
 Summary: a complete toolbox
 Home-page: UNKNOWN
 Author: Erwan Le Nagard
 Author-email: erwan@opsci.ai
 License: MIT
 Platform: UNKNOWN
-Requires-Dist: Pillow (<11.0.0,>=9.0.1)
-Requires-Dist: Requests (==2.31.0)
+Requires-Dist: Pillow (>=9.0.1)
+Requires-Dist: Requests (==2.32.3)
 Requires-Dist: beautifulsoup4 (==4.10.0)
+Requires-Dist: chardet (>=4.0.0)
 Requires-Dist: chart-studio (==1.1.0)
 Requires-Dist: eldar (==0.0.8)
 Requires-Dist: emoji (==2.10.1)
+Requires-Dist: fa2-modified (==0.3.10)
 Requires-Dist: google-api-python-client (==2.122.0)
-Requires-Dist: gspread (==6.1.1)
+Requires-Dist: gspread (==6.1.2)
 Requires-Dist: hdbscan (==0.8.33)
 Requires-Dist: jusText (==3.0.0)
 Requires-Dist: langchain (==0.1.20)
-Requires-Dist: matplotlib (>=3.5.1)
+Requires-Dist: matplotlib (>=3.9.0)
+Requires-Dist: mysql-connector-repackaged (==0.3.1)
 Requires-Dist: networkx (==3.2.1)
 Requires-Dist: nltk (==3.8.1)
 Requires-Dist: numpy (<1.25.0,>=1.21.5)
 Requires-Dist: opencv-python-headless (==4.9.0.80)
 Requires-Dist: openpyxl (==3.1.3)
-Requires-Dist: pandas (==1.5.3)
+Requires-Dist: pandas (>=1.5.3)
 Requires-Dist: plotly (==5.19.0)
-Requires-Dist: protobuf (<5,>=3.20)
-Requires-Dist: pyarrow (==14.0.2)
+Requires-Dist: protobuf (==4.23.4)
+Requires-Dist: pyarrow (>=14.0.2)
 Requires-Dist: python-louvain (==0.16)
 Requires-Dist: scikit-learn (==1.4.1.post1)
 Requires-Dist: scipy (<2.0.0,>=1.8.0)
@@ -36,7 +39,7 @@ Requires-Dist: setuptools (==59.6.0)
 Requires-Dist: spacy (==3.7.4)
 Requires-Dist: spacy-language-detection (==0.2.1)
 Requires-Dist: spacymoji (==3.1.0)
-Requires-Dist: supervision (==0.20.0)
+Requires-Dist: supervision (==0.21.0)
 Requires-Dist: textacy (==0.13.0)
 Requires-Dist: torch (==2.0.1)
 Requires-Dist: tqdm (==4.66.2)

opsci_toolbox-0.0.9.dist-info/RECORD

@@ -0,0 +1,22 @@
+opsci_toolbox/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+opsci_toolbox/apis/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+opsci_toolbox/apis/rapidapi_helpers.py,sha256=k_hYcRNww5noNkX7zyz5Htggxb15BPoKSlbY7NLuQXI,26696
+opsci_toolbox/apis/webscraping.py,sha256=Gz3hOfhOHUpwHU1Pzj3mB2WdBAcKa2WisYBHMi3lcVE,18343
+opsci_toolbox/apis/youtube_helpers.py,sha256=j4hwCS2BEWRJjd9Q5XBN9FeCrL3lqteyz5dqbtfypdo,17418
+opsci_toolbox/helpers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+opsci_toolbox/helpers/common.py,sha256=lemGhNwWIxaMwo-X7UsksUMGLV-IOuX_XwC82a50GD4,44672
+opsci_toolbox/helpers/cv.py,sha256=N3hnLX223UQbdw_YEdUYj10xUXT_95O6BpQt6TbAE08,21092
+opsci_toolbox/helpers/dataviz.py,sha256=IfHByNWAU2rErZMfs3LuwZwJApLN5w320JEbBPuVp6U,115856
+opsci_toolbox/helpers/dates.py,sha256=Wf7HxaUY62IRrY3XPdRIuoaMbGi3QqWf-vStqbRRY_o,2633
+opsci_toolbox/helpers/nlp.py,sha256=r4o7V9tJrj3xt34O_4hN0szbSB4RmveP8qmwCqHOxEY,87988
+opsci_toolbox/helpers/nlp_cuml.py,sha256=XzBfoFMpVIehpRbp60E4wGokpoqJP0lJxs1plOxQqBY,28882
+opsci_toolbox/helpers/sna.py,sha256=XL1BZ-x83xWRNbGsvh7-m8Mdy6iOrWx8vjgaL2_TSmo,31905
+opsci_toolbox/helpers/sql.py,sha256=LMrDWcv1QpfE8HyyrqiKuhhkt930lvME3-AKU89LF38,1928
+opsci_toolbox/helpers/surreaction.py,sha256=JjVvHs7Sf9IJxX0QdHpQ_3E8-c_OS6q_bfUKvurl1z4,7093
+opsci_toolbox/lexicons/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+opsci_toolbox/lexicons/stop_words_en.csv,sha256=4lzjBZHCn_b3lg_CUNkmA_MDQ7DLEpS83k6-dWpkC2o,1957
+opsci_toolbox/lexicons/stop_words_fr.csv,sha256=sPdA8VmyNYbiHg-M8O3tg7ayHvCE3GDg6cF-oSZxICM,6776
+opsci_toolbox-0.0.9.dist-info/METADATA,sha256=OZpumYsT_k69veurKrN3fsY45v8h46ZTgbpLRNVMJYA,1716
+opsci_toolbox-0.0.9.dist-info/WHEEL,sha256=G16H4A3IeoQmnOrYV4ueZGKSjhipXx8zc8nu9FGlvMA,92
+opsci_toolbox-0.0.9.dist-info/top_level.txt,sha256=fUiqxou4FPec_tOfauTLCKAuepeYLfRyhedycWxVnq4,14
+opsci_toolbox-0.0.9.dist-info/RECORD,,

opsci_toolbox-0.0.7.dist-info/RECORD

@@ -1,21 +0,0 @@
-opsci_toolbox/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-opsci_toolbox/apis/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-opsci_toolbox/apis/rapidapi_helpers.py,sha256=f2o4ItMZwoAt3ow5bSK-MPkqzP3wzJ857xU0CzDZIyI,23207
-opsci_toolbox/apis/webscraping.py,sha256=D1A_ixjImPOncbWrKf6Nem2SR4NQraxTbcYqiE64VTY,12263
-opsci_toolbox/apis/youtube_helpers.py,sha256=CZQ4mP43eA3STWNJ0HjSoJpvz3iHzohSGxmp5ntEgpA,13115
-opsci_toolbox/helpers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-opsci_toolbox/helpers/common.py,sha256=TvlGcCdpkfKUaDkahILq3wFLgxwAtgRv5KJRoNy9brw,40339
-opsci_toolbox/helpers/cv.py,sha256=-uXHncyAr8sDF0ip32LAz7Xae9Z4-T9MH6palpIzq-c,21109
-opsci_toolbox/helpers/dataviz.py,sha256=JbudfwWPCEEEzP8Vpmu1CMEKaE6O2vtk9xsflW2pT1M,112451
-opsci_toolbox/helpers/dates.py,sha256=EvNqut2s6S4CaaVFQhIDR-W00TZbt3J04yRYKYhxCkU,2638
-opsci_toolbox/helpers/nlp.py,sha256=jpZRyTkYeoVH8tzqIT0opZn5unt8cdU1qPdFzXxEOw8,86638
-opsci_toolbox/helpers/nlp_cuml.py,sha256=w-pkch2Sk_FfVrm1j8NUmmxVvoJXJHuXzGnXGV_FWSE,14153
-opsci_toolbox/helpers/sna.py,sha256=SZjS21qfBmlkHDJaXi7CaHpj6KhefcsDmJ1A9NRtVeQ,12006
-opsci_toolbox/helpers/surreaction.py,sha256=JjVvHs7Sf9IJxX0QdHpQ_3E8-c_OS6q_bfUKvurl1z4,7093
-opsci_toolbox/lexicons/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-opsci_toolbox/lexicons/stop_words_en.csv,sha256=4lzjBZHCn_b3lg_CUNkmA_MDQ7DLEpS83k6-dWpkC2o,1957
-opsci_toolbox/lexicons/stop_words_fr.csv,sha256=sPdA8VmyNYbiHg-M8O3tg7ayHvCE3GDg6cF-oSZxICM,6776
-opsci_toolbox-0.0.7.dist-info/METADATA,sha256=ErIa8rDRfvT52LjZJcSKU7zougC_1hZa3oWnvPPTzJQ,1601
-opsci_toolbox-0.0.7.dist-info/WHEEL,sha256=G16H4A3IeoQmnOrYV4ueZGKSjhipXx8zc8nu9FGlvMA,92
-opsci_toolbox-0.0.7.dist-info/top_level.txt,sha256=fUiqxou4FPec_tOfauTLCKAuepeYLfRyhedycWxVnq4,14
-opsci_toolbox-0.0.7.dist-info/RECORD,,