python-examples 0.2.0__py3-none-any.whl

Algorithms/static_analysis/deduplicate_security_findings.py

@@ -0,0 +1,22 @@
+from typing import List, Dict
+
+
+def deduplicate(findings: List[Dict]) -> List[Dict]:
+    seen = set()
+    output = []
+    for finding in findings:
+        key = (finding["file"], finding["line"], finding["rule"])
+        if key not in seen:
+            seen.add(key)
+            output.append(finding)
+
+    return output
+
+
+findings = [
+    {"file": "a.py", "line": 10, "rule": "SQL001"},
+    {"file": "a.py", "line": 10, "rule": "SQL001"},
+    {"file": "b.py", "line": 20, "rule": "XSS001"},
+]
+
+print(deduplicate(findings))

Algorithms/static_analysis/package_dependency.py

@@ -0,0 +1,70 @@
+from typing import Dict, List
+
+
+def find_dependency_cycle(deps: Dict[str, List[str]]) -> List[List[str]]:
+    """
+    dfs back edges for cycle detection
+    """
+    visited = set()
+    visiting = set()
+    # there may be more than one cycle
+    path = []
+    cycles = []
+
+    def dfs(node):
+        if node in visiting:
+            idx = path.index(node)
+            cycles.append(path[idx:] + [node])
+            return
+
+        if node in visited:
+            return
+
+        visiting.add(node)
+        visited.add(node)
+        path.append(node)
+
+        for neighbor in deps[node]:
+            dfs(neighbor)
+
+        path.pop()
+        visiting.remove(node)
+
+    for node in deps:
+        if node not in visited:
+            dfs(node)
+
+    return cycles
+
+
+def find_dependency_cycle_stack(deps: Dict[str, List[str]]) -> List[List[str]]:
+    """
+    dfs back edges for cycle detection
+    """
+    visited = set()
+    visiting = set()
+    # there may be more than one cycle
+    path = []
+    cycles = []
+    for start in deps:
+        if start not in visited:
+            stack = [(start, False)]
+            while stack:
+                node, exiting = stack.pop()
+                if exiting:
+                    path.pop()
+                    visiting.remove(node)
+                    visited.add(node)
+                # back edge
+                if node in visiting:
+                    idx = path.index(node)
+                    cycles.append(path[idx:] + [node])
+                    continue
+                if node in visited:
+                    continue
+                visiting.add(node)
+                path.append(node)
+                stack.append((node, True))
+                for neighbor in reversed(deps[node]):
+                    stack.append((neighbor, False))
+    return cycles

Algorithms/static_analysis/rule_matcher.py

@@ -0,0 +1,70 @@
+from typing import List, Dict
+import re
+
+
+def find_violations(code: List[str], rules: List[str]):
+    """
+    This function takes a list of code lines and a list of rules, and returns a list of violations found in the code.
+    """
+    violations = []
+    for rule in rules:
+        pattern = rule["pattern"]
+        severity = rule["severity"]
+        for line_number, line in enumerate(code):
+            if pattern in line:
+                violations.append(
+                    {
+                        "line_number": line_number + 1,
+                        "line": line,
+                        "pattern": pattern,
+                        "severity": severity,
+                    }
+                )
+    return violations
+
+
+def compile_rule(pattern):
+    METAVAR = re.compile(r"\$([A-Za-z_][A-Za-z0-9_]*)")
+    captures = []
+    regex_parts = []
+    last = 0
+    for match in METAVAR.finditer(pattern):
+        regex_parts.append(re.escape(pattern[last : match.start()]))
+        name = match.group(1)
+        captures.append(name)
+
+        regex_parts.append(f"(?P<{name}>.*?)")
+        last = match.end()
+    regex_parts.append(re.escape(pattern[last:]))
+    return re.compile("^" + "".join(regex_parts) + "$"), captures
+
+
+def find_violations_v2(code: List[str], rules: List[Dict]) -> List[Dict]:
+    """
+    Support wildcards
+    """
+    compiled_rules = []
+    for rule in rules:
+        regex_parts, captures = compile_rule(rule["pattern"])
+        compiled_rules.append(
+            {
+                "regex": regex_parts,
+                "captures": captures,
+                "severity": rule["severity"],
+                "pattern": rule["pattern"],
+            }
+        )
+    violations = []
+    for line_number, line in enumerate(code):
+        for rule in compiled_rules:
+            match = rule["regex"].match(line)
+            if match:
+                violations.append(
+                    {
+                        "line_number": line_number + 1,
+                        "pattern": rule["pattern"],
+                        "severity": rule["severity"],
+                        "captures": match.groupdict(),
+                    }
+                )
+    return violations

Algorithms/tensors/broadcast.py

@@ -0,0 +1,98 @@
+import numpy as np
+
+
+def normalize_l2(A: np.array, dim: int) -> np.array:
+    """
+    input:
+    A: [D1,D2,...]
+    operations:
+    keepdims preserves the dimension. For instance:
+    A       [B, N, D]
+    norm    [B, N, 1]
+    output:
+    A/norm: [D1,D2,...] same shape but normalize along given axis/dim
+    """
+    norm = np.sqrt((A**2).sum(axis=dim, keepdims=True))
+    return A / norm
+
+
+def layer_norm(A: np.array) -> np.array:
+    """
+    input:
+    A: [B, N, D] (batch, seq len, feature dimension)
+    operations: keepdims used to retain original dimensions for broadcasting
+    """
+    if len(A.shape) != 3:
+        raise ValueError("Input must be a 3D array with shape [B, N, D]")
+    means = A.mean(axis=2, keepdims=True)
+    vars = A.var(axis=2, keepdims=True)
+
+    return (A - means) / np.sqrt(vars + 1e-5)
+
+
+def batch_norm(A: np.array) -> np.array:
+    """
+    input:
+    A: [B, N, D] (batch, seq len, feature dimension)
+    operations:
+    pool batch and sequence length so we normalize each feature independently
+    using the pooled batch statistics. keepdims used to retain original dimensions for broadcasting
+    """
+    if len(A.shape) != 3:
+        raise ValueError("Input must be a 3D array with shape [B, N, D]")
+    means = A.mean(axis=(0, 1), keepdims=True)
+    vars = A.var(axis=(0, 1), keepdims=True)
+
+    return (A - means) / np.sqrt(vars + 1e-5)
+
+def pairwise_cosine(A: np.array) -> np.array:
+    """
+    input:
+    A: [N, D]
+
+    output:
+    [N, N]: each entry in matrix is cosine similarity
+    """
+    norm = np.sqrt((A**2).sum(axis=1, keepdims=True))
+    normalized = A / norm
+    return normalized @ normalized.T
+
+def pairwise_cosine_broadcast(A: np.array) -> np.array:
+    """
+    input:
+    A: [N, D]
+
+    output:
+    [N, N]: each entry in matrix is cosine similarity
+    """
+    norm = np.sqrt((A**2).sum(axis=1, keepdims=True))
+    normalized = A / norm
+    return (normalized[:, None, :] * normalized[None, :, :]).sum(axis=-1)
+
+def feature_thresholds(A: np.array, thresholds: np.array) -> np.array:
+    """
+    input: 
+    A: [B, N, D]
+    thresholds: [D] for each dimension
+
+    output:
+    [B, N, D] with features below threshold masked out
+    """
+    mask = A > thresholds
+    return A * mask
+
+def closest_pairwise(A: np.array) -> np.array:
+    """
+    input:
+    A: [N, D]
+    
+    operations:
+    broadcast pairwise distances, filling diagonal self distances with inf
+    as these are trivially 0.
+
+    output: 
+    result: [N], the index closest to each point
+    """
+    pairwise_dists = np.sum((A[:, None, :] - A[None, :, :])**2, axis=2)
+    np.fill_diagonal(pairwise_dists, np.inf)
+    return np.argmin(pairwise_dists, axis=1)

Algorithms/tensors/kmeans.py

@@ -0,0 +1,49 @@
+import numpy as np
+
+def generate_centers(k: int,
+                     dim: int,
+                     mn: np.array,
+                     mx: np.array):
+  return mn + np.random.rand(k, dim)*(mx-mn)
+
+def k_means(k: int, data: np.array, iterations: int):
+  """
+  given a numpy dataset, apply vector quantization to model probability
+  density functions by distribution of prototype functions.
+
+  array of tuples to list "tolist()" for the standard matrix format.
+  Or np.vstack
+
+  ## Annotate tensor sizes ##
+  data: [num_points, feature_dimension]
+  output:
+  centers: [k, feature_dimension]
+  labels: [num_points, feature_dimension]
+  """
+  # data = np.array(data.tolist())
+  data = np.vstack(data)
+  # axis is column 0 rows 1.
+  mn, mx = data.min(axis=0), data.max(axis=0)
+  # randomly generate centers
+  centers = generate_centers(k=k,
+                             dim=data.shape[-1],
+                             mn=mn,
+                             mx=mx)
+  for _ in range(iterations):
+    # distances: [num_points, num_centers (k), feature_dimension]
+    # squared norm, at least avoids extra square root (monotonic increasing
+    # function)
+    distances = np.sum((data[:, None, :] - centers[None, :, :]) ** 2,
+                       axis=2)
+
+    # Which center is closest to each point?
+    labels = np.argmin(distances, axis=1)
+
+    # Recompute centers
+    for j in range(k):
+        points = data[labels == j]
+
+        if len(points) > 0:
+            centers[j] = points.mean(axis=0)
+
+  return centers, labels

LLMs/torch_examples/batch_agg.py

@@ -0,0 +1,78 @@
+import torch
+
+
+def standardize(M: torch.Tensor) -> torch.Tensor:
+    """
+    standardize standardizes each row of the input matrix M to have mean 0 and std 1.
+    Arguments:
+        M: input tensor of shape (n, p)
+    Returns:
+        A tensor of shape (n, p) where each row has mean 0 and std 1.
+    """
+    return (M - M.mean(axis=1).unsqueeze(1)) / M.std(axis=1).unsqueeze(1)
+
+
+def normalize_per_batch(p: int, num_samples: int = 100, batch_size: int = 10):
+    """
+    normalize_per_batch generates num_samples random p-dim vectors,
+    splits them into batches of size batch_size (last batch may be smaller),
+    and standardizes each batch to have mean 0 and std 1 per dimension.
+      Arguments:
+          p: dimension of the vectors
+          num_samples: total number of samples to generate
+          batch_size: size of each batch
+      Returns:
+          A tensor of shape (num_samples, p) containing the standardized vectors.
+    """
+    if batch_size > num_samples:
+        raise ValueError("batch_size must be at most number of samples.")
+    mat = torch.randn((num_samples, p), dtype=torch.float32)
+    num_batches = num_samples // batch_size
+    remainder = num_samples % batch_size
+    num_batches += int(remainder != 0)
+    if remainder == 0:
+        # evenly split
+        batch_mat = mat.view(num_batches, batch_size, p)
+        means = batch_mat.mean(dim=1, keepdim=True)  # (num_batches, 1, p)
+        stds = batch_mat.std(dim=1, keepdim=True)  # (num_batches, 1, p)
+        standardized = (batch_mat - means) / (stds + 1e-8)
+        return standardized.view(num_samples, p)
+    else:
+        # scattered
+        batch_ids = torch.randint(0, num_batches, (num_samples,))
+        # count per group
+        counts = torch.bincount(batch_ids, minlength=num_batches).unsqueeze(1)
+        batch_ids_processed = batch_ids.unsqueeze(1).expand(-1, p)
+        sum_per_group = torch.zeros((num_batches, p)).scatter_add_(
+            0, batch_ids_processed, mat
+        )
+        mean_per_group = sum_per_group / counts.clamp(min=1)
+
+        sum_sq = (mat - mean_per_group[batch_ids]) ** 2
+        sum_sq_per_group = torch.zeros((num_batches, p)).scatter_add_(
+            0, batch_ids_processed, sum_sq
+        )
+        var_per_group = sum_sq_per_group / counts.clamp(min=1)
+        std_per_group = torch.sqrt(var_per_group + 1e-8)
+        return (mat - mean_per_group[batch_ids]) / (std_per_group[batch_ids])
+
+
+def sample_gaussian_pairs(p: int, num_samples: int = 10000, eps: float = 1e-8):
+    """
+    sanple_gaussian_pairs generates num_samples pairs of p-dimensional vectors
+    from standard normal distribution, and computes their normalized inner products.
+    Highlights that high-dimensional random vectors are almost orthogonal.
+    Arguments:
+      p: dimension of the vectors
+      num_samples: number of pairs to sample
+      eps: small value to avoid division by zero
+    Returns:
+      A tensor of shape (num_samples,) containing the normalized inner products.
+    """
+    pair_mat = torch.randn((2 * num_samples, p), dtype=torch.float32)
+    pair_mat = pair_mat.view(num_samples, 2, p)
+    norm_first = torch.norm(pair_mat[:, 0, :], dim=1)
+    norm_second = torch.norm(pair_mat[:, 1, :], dim=1)
+    dot_prod = (pair_mat[:, 0, :] * pair_mat[:, 1, :]).sum(dim=1)
+    norm_inner_prods = dot_prod / (norm_first * norm_second + eps)
+    return norm_inner_prods

LLMs/torch_examples/pooling.py

@@ -0,0 +1,26 @@
+import torch
+
+
+class VariableSortedHistoryPooling(torch.nn.Module):
+    def __init__(self, n_samples: int, emb_dim: int):
+        super(VariableSortedHistoryPooling, self).__init__()
+        # n samples are n events, where it's consecutive events belonging to a given user
+        # The n samples can be segmented into B users.
+        self.emb = torch.nn.Embedding(n_samples, emb_dim)
+
+    def forward(
+        self, event_indices: torch.Tensor, offsets: torch.Tensor
+    ) -> torch.Tensor:
+        event_embs = self.emb(event_indices)
+        # diffs of cumulative offsets gives user lengths (number of events in history per user)
+        user_lengths = offsets[1:] - offsets[:-1]
+        user_ids = torch.repeat_interleave(
+            torch.arange(len(user_lengths), device=offsets.device), user_lengths
+        )
+        target = torch.zeros(
+            len(user_lengths), event_embs.shape[1], device=event_embs.device
+        )
+        target = target.scatter_add(
+            dim=0, index=user_ids.unsqueeze(1).expand_as(event_embs), src=event_embs
+        )
+        return target / user_lengths.clamp(min=1).unsqueeze(1)

LLMs/torch_examples/shape_literacy.py

@@ -0,0 +1,37 @@
+import torch
+
+x = torch.randn(10)
+y = x.unsqueeze(1)
+print(x.shape, y.shape)
+
+x = torch.randn(4, 1, 8)
+y = x.squeeze()
+print(x.shape, y.shape)
+
+x = torch.randn(2, 3, 4)
+print(x, x.shape)
+# reshape to same number of elements, but different shape
+y = x.view(12, 2)
+print(y, y.shape)
+z = x.reshape(12, 2)
+print(z, z.shape)
+
+x = torch.randn(5, 1)
+z = x.expand(5, 3)
+print(x, y)
+print(x.shape, z.shape)
+
+# copies the data
+y = x.repeat(1, 3)
+print(y)
+print(y.shape)
+y[0, 0] = 10
+print("Y", y)
+
+
+y2 = x.expand_as(torch.randn(5, 10))
+# expanded size to match existing size at dim 0.
+# expand doesn't allocate new memory, so changing y2 will change x
+y3 = x.expand(5, 2)
+y3[0, 0] = 20
+print(y3)

LLMs/xai.py

@@ -0,0 +1,92 @@
+from typing import List
+import numpy as np
+from dataclasses import dataclass
+
+REQUEST_QUEUE = []
+VOCAB_SIZE = 10
+
+
+def lm_batch(prev_tokens: List[List[int]]):
+    next_tokens = []
+    for sequence in prev_tokens:
+        next_tokens.append(hash(tuple(sequence)) % VOCAB_SIZE)
+    return next_tokens
+
+
+class ReturnHandle:
+    RETURN = dict()
+
+    def __init__(self, key):
+        self.key = key
+
+    def return_result(self, sequence: List[int]):
+        self.__class__.RETURN[self.key] = sequence
+
+
+@dataclass
+class Request:
+    prompt: List[int]
+    handle: ReturnHandle
+
+
+def process_loop(batch_size=8, max_len=20, stop_token=0):
+    active = batch_size * [None]
+    while True:
+        i = 0
+        while i < batch_size:
+            elem = dequeue()
+            if elem:
+                active[i] = [elem, np.array([])]
+            else:
+                break
+            i += 1
+        print(f"Batch Length: {i}")
+
+        if i == 0:
+            return
+        for iter in range(1, max_len + 1):
+            contexts = [
+                np.concatenate((val[0].prompt, val[1]))
+                for val in active
+                if val is not None
+            ]
+            next_tokens = lm_batch(contexts)
+            if len(next_tokens) == 0:
+                break
+            for j in range(len(next_tokens)):
+                if active[j]:
+                    if next_tokens[j] == stop_token or iter == max_len:
+                        print(f"Iter: {iter}: ", next_tokens[j])
+                        active[j][0].handle.return_result(active[j][1])
+                        active[j] = None
+                    else:
+                        # print("Before", active[j][1])
+                        active[j][1] = np.append(active[j][1], next_tokens[j])
+                        # print("After", active[j][1])
+
+        if all([val is None for val in active]) and not REQUEST_QUEUE:
+            return
+
+
+def _enqueue(num_entries=20):
+    np.random.seed(42)
+    for i in range(num_entries):
+        prompt: List[int] = np.random.randint(0, high=10, size=100)
+        handle = ReturnHandle(i)
+        REQUEST_QUEUE.append(Request(prompt, handle))
+
+
+def dequeue():
+    if REQUEST_QUEUE:
+        return REQUEST_QUEUE.pop(0)
+    else:
+        return None
+
+
+if __name__ == "__main__":
+    _enqueue(num_entries=20)
+    assert len(REQUEST_QUEUE) == 20, "Not initialized correctly"
+    process_loop()
+    print("\n", "#" * 10 + "  RESULT  " + "#" * 10, "\n")
+    for k, v in ReturnHandle.RETURN.items():
+        print(f"{k}: {v}")

mixins/benchmark.py

@@ -0,0 +1,16 @@
+import time
+from typing import Callable
+
+
+class BenchmarkMixin:
+    def benchmark(self, fn: Callable, *args, **kwargs):
+        start = time.perf_counter()
+
+        result = fn(*args, **kwargs)
+
+        elapsed = time.perf_counter() - start
+
+        return {
+            "result": result,
+            "elapsed_seconds": elapsed,
+        }

mixins/logging.py

@@ -0,0 +1,7 @@
+import logging
+
+
+class LoggingMixin:
+    @property
+    def logger(self):
+        return logging.getLogger(self.__class__.__name__)

python_examples-0.2.0.dist-info/METADATA

@@ -0,0 +1,32 @@
+Metadata-Version: 2.4
+Name: python-examples
+Version: 0.2.0
+Summary: Algorithms and systems examples repo
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy>=1.23.5
+Dynamic: license-file
+
+# python examples
+Practice with Jupyter Notebook, Python, and Algorithms
+
+#### Review 
+* Python defines a default constructor in the class, which exists regardless of created constructor unlike Java.
+* Python has duck typing so it doesn't enforce type hints at runtime. It only cares about if the object has existing methods. Java is statically typed and enforces strict inheritance rules at compile time, so a parent object passed into an argument expecting a child class will raise a compile time error.
+* Python has mutable default arguments, so use None on the list instead.
+* In Python, modifying a list cannot be done while iterating over it.
+* Python has double equal sign that checks for value equality. `is` confirms if two objects/variables are the same, so:
+    ```python
+    a = 256
+    b = 256
+    print(a is b)
+    ```
+    * The print statement returns True because Python optimizes by caching small values -5 to 256 and short strings into memory. However, if the two variables were assigned to 257, they are not equal.
+    * Defining a mutable value in python class body updates the value to be shared by all instances of the class.
+* In exception handling, we have a try finally statement that both contain `return 1` and `return 2` then finally return would hijack the execution. Finally should not contain return statements.
+* For multithreaded work, CPU bounded work will run slower due to competition for a single lock. For I/O heavy work, GIL is released when waiting on network responses and threading works good for I/O tasks.
+* For circular imports, we can avoid this by defining a third file or by doing a local import within a method or local scope. 
+* += mutates in place but `a = a + [1]` creates a new list.
+* `__eq__` verifies object representation of the same value. When used in a set/dictionary, `__hash__` needs to be implemented.
+* `@staticmethod` in python is a normal function that lives in the class's namespace.

python_examples-0.2.0.dist-info/RECORD

@@ -0,0 +1,31 @@
+Algorithms/arrays/subsequence_conflict.py,sha256=_a9bgsLQawSBR_7oYFE_25BAywREwZwdkT3S7cfTljY,863
+Algorithms/matrices/utils.py,sha256=SSzK-kSYXvr18pHWvcutzwupNoCvbNH1EZIcp9T2UuI,1631
+Algorithms/numerical_methods/coin_run.py,sha256=5IrUz76NDHcPNhiwqJOrMt1AKMpbkTl9aLRXubz1YW4,2214
+Algorithms/numerical_methods/euler/p0.py,sha256=p8W86lxtzu_DB4Bd-8KNQGMujA5MlTQmzwXozKub9cY,224
+Algorithms/numerical_methods/euler/p1.py,sha256=Zpshpb43gaJlOz6sPneY3TW9_2PpqZsYw82S2MKjGDM,142
+Algorithms/numerical_methods/euler/p2.py,sha256=QDgctFowoFqkgI0axlqd2zLe0yLPKRiz7KmMZoFHV8E,326
+Algorithms/numerical_methods/euler/p48.py,sha256=oN2xwCiruIpFbMC4ADUvIb6ykVo9Y_pDHl_Y2Sov0E4,205
+Algorithms/numerical_methods/euler/p49.py,sha256=4xCNiQT32RMKKfYx1f15g-JjMIexcuC8mmW4BiD_C_s,2735
+Algorithms/numerical_methods/euler/p50.py,sha256=yGZw2D91jPhZtWRPZJ3pFz4fBiqWF07wPo0CA-J_goE,782
+Algorithms/numerical_methods/euler/p51.py,sha256=_UxNHlasdUwhr05w0b_JVVdPp8egjiNw9bSd_FcTLMM,1595
+Algorithms/numerical_methods/euler/p54.py,sha256=TRf_aKKvKnIGvZutwoVGeeRj_kNIB9-TY7tApwhuJtM,4413
+Algorithms/numerical_methods/euler/utils.py,sha256=Rdadl4mjiRiVQ2YfvD8G0OYrdCGH_lGFda3InErMgNk,358
+Algorithms/slidingWindow/longestUnique.py,sha256=8_8GYIsdhsG0ClREbiLkgGqDOwVTb5vx6wASEnrKRjg,1104
+Algorithms/static_analysis/ast_tree.py,sha256=CtyLr-YY_I3JODk9JqlLv9S-5aF3ySyO5-nqNLqMEmQ,2251
+Algorithms/static_analysis/deduplicate_security_findings.py,sha256=PV1lw-XpH6BXESxzpbMIZSudhS5LSdTg4-rwGXK05gY,524
+Algorithms/static_analysis/package_dependency.py,sha256=jd8eNuXVQrJ2oueIQL1baa7egg0l1zIT6Xt-qDAIT-g,1799
+Algorithms/static_analysis/rule_matcher.py,sha256=5ynJZ-HyPVrREQb3yn_r79R1kQgiwW3ZdV6iVGfoavI,2195
+Algorithms/tensors/broadcast.py,sha256=2P5vBEKDVBWkZA2drihMI7HS9EJqAtAyfmOsBfRqoYw,2675
+Algorithms/tensors/kmeans.py,sha256=xPhjVhSW8v89KKazVkq18cML58bdJ7iSADQUQqV6kVA,1516
+LLMs/xai.py,sha256=QkuXKtKNsEAvuZy1eUMvIRHifz_lIWTu7O9L3yrHUyQ,2522
+LLMs/torch_examples/batch_agg.py,sha256=KHGZDfBQt6M5JJvrkGIfTeK1pz8jc-nUpo5u-qSJTl0,3384
+LLMs/torch_examples/pooling.py,sha256=F6a89eRsmZ_iMjwUGtx-LyNkXO1yLF_k-g6M0rC9cNc,1130
+LLMs/torch_examples/shape_literacy.py,sha256=KuQ0VJEJN-gztzZ3ZYJY2n2vIlGDMfss43RUpI3dPGY,686
+mixins/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+mixins/benchmark.py,sha256=dTUcJPvtJGtsJ1YAyyuidA-HEl8xx4MRNU9Tc-ScFX4,338
+mixins/logging.py,sha256=TWUb-gSCQsZyZDKMvl-wfL_yKQG13UdPd7ERjyrBOd8,130
+python_examples-0.2.0.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
+python_examples-0.2.0.dist-info/METADATA,sha256=iWSHKtN13_Kz8XsvVRSpxZieZBedrJr716xcCQAxO3g,2193
+python_examples-0.2.0.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+python_examples-0.2.0.dist-info/top_level.txt,sha256=1qDk8V1ZB6dlQn_r62lGHhMUkVuKsyPqH1vJJor6Wrc,23
+python_examples-0.2.0.dist-info/RECORD,,

python_examples-0.2.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+