skylos 2.1.1__py3-none-any.whl → 2.2.2__py3-none-any.whl

skylos/rules/secrets.py

@@ -0,0 +1,268 @@
+from __future__ import annotations
+import re, ast
+from math import log2
+from typing import Dict, Any, Iterable, List, Optional
+
+__all__ = ["scan_ctx"]
+
+ALLOWED_FILE_SUFFIXES = (".py", ".pyi", ".pyw")
+
+PROVIDER_PATTERNS = [
+    ("github", re.compile(r"(ghp|gho|ghu|ghs|ghr|gpat)_[A-Za-z0-9]{36,}")),
+    ("gitlab", re.compile(r"glpat-[A-Za-z0-9_-]{20,}")),
+    ("slack", re.compile(r"xox[abprs]-[A-Za-z0-9-]{10,48}")),
+    ("stripe", re.compile(r"sk_(live|test)_[A-Za-z0-9]{16,}")),
+    ("aws_access_key_id", re.compile(r"\b(AKIA|ASIA|AGPA|AIDA|AROA|AIPA)[0-9A-Z]{16}\b")),
+    ("google_api_key", re.compile(r"\bAIza[0-9A-Za-z\-_]{35}\b")),
+    ("sendgrid", re.compile(r"\bSG\.[A-Za-z0-9_-]{16,}\.[A-Za-z0-9_-]{16,}\b")),
+    ("twilio", re.compile(r"\bSK[0-9a-fA-F]{32}\b")),
+    ("private_key_block", re.compile(r"-----BEGIN (?:RSA|DSA|EC|OPENSSH|PGP) PRIVATE KEY-----")),
+]
+
+GENERIC_VALUE = re.compile(r"""(?ix)
+    (?:
+      (token|api[_-]?key|secret|password|passwd|pwd|bearer|auth[_-]?token|access[_-]?token)
+      \s*[:=]\s*(?P<q>['"])(?P<val>[^'"]{16,})(?P=q)
+    )|(?P<bare>[A-Za-z0-9_\-]{24,})
+""")
+
+SAFE_TEST_HINTS = {
+    "example", "sample", "fake", "placeholder", "dummy", "test_", "_test", "test_test_", 
+    "changeme", "password", "secret", "not_a_real", "do_not_use",
+}
+
+IGNORE_DIRECTIVE = "skylos: ignore[SKY-S101]"
+DEFAULT_MIN_ENTROPY = 3.6
+
+def _entropy(s):
+    if len(s) == 0:
+        return 0.0
+    
+    char_counts = {}
+    for character in s:
+        if character in char_counts:
+            char_counts[character] += 1
+        else:
+            char_counts[character] = 1
+    
+    total_chars = len(s)
+    entropy = 0.0
+    
+    for count in char_counts.values():
+        probability = count / total_chars
+        entropy -= probability * log2(probability)
+    
+    return entropy
+
+def _mask(tok):
+    token_length = len(tok)
+    
+    if token_length <= 8:
+        return "*" * token_length
+    
+    else:
+        first_part = tok[:4]
+        last_part = tok[-4:]
+        return first_part + "…" + last_part
+
+def _docstring_lines(tree):
+    if tree is None:
+        return set()
+    
+    docstring_line_numbers = set()
+
+    def find_docstring_lines(node):
+        if not hasattr(node, "body") or not node.body:
+            return
+        
+        first_statement = node.body[0]
+        
+        is_expression = isinstance(first_statement, ast.Expr)
+        if not is_expression:
+            return
+            
+        value = getattr(first_statement, "value", None)
+        if not isinstance(value, ast.Constant):
+            return
+            
+        if not isinstance(value.value, str):
+            return
+        
+        start_line = getattr(first_statement, "lineno", None)
+        end_line = getattr(first_statement, "end_lineno", start_line)
+        
+        if start_line is not None:
+            if end_line is None:
+                end_line = start_line
+            
+            for line_num in range(start_line, end_line + 1):
+                docstring_line_numbers.add(line_num)
+
+    if isinstance(tree, ast.Module):
+        find_docstring_lines(tree)
+
+    for node in ast.walk(tree):
+        if isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef, ast.ClassDef)):
+            find_docstring_lines(node)
+    
+    return docstring_line_numbers
+
+def scan_ctx(ctx, *, min_entropy= DEFAULT_MIN_ENTROPY, scan_comments= True,
+              scan_docstrings= True, allowlist_patterns= None, ignore_path_substrings= None):
+    
+    rel_path = ctx.get("relpath", "")
+    if not rel_path.endswith(ALLOWED_FILE_SUFFIXES):
+        return []
+    
+    if ignore_path_substrings:
+        for substring in ignore_path_substrings:
+            if substring and substring in rel_path:
+                return []
+    
+    file_lines = ctx.get("lines") or []
+    syntax_tree = ctx.get("tree")
+    
+    allowlist_regexes = []
+    if allowlist_patterns:
+        for pattern in allowlist_patterns:
+            compiled_regex = re.compile(pattern)
+            allowlist_regexes.append(compiled_regex)
+    
+    if scan_docstrings:
+        docstring_lines = set()
+    else:
+        docstring_lines = _docstring_lines(syntax_tree)
+    
+    findings = []
+    
+    for line_number, raw_line in enumerate(file_lines, start=1):
+        line_content = raw_line.rstrip("\n")
+        
+        if IGNORE_DIRECTIVE in line_content:
+            continue
+        
+        stripped_line = line_content.lstrip()
+        if not scan_comments and stripped_line.startswith("#"):
+            continue
+        
+        if not scan_docstrings and line_number in docstring_lines:
+            continue
+        
+        should_skip_line = False
+        for regex_pattern in allowlist_regexes:
+            if regex_pattern.search(line_content):
+                should_skip_line = True
+                break
+        
+        if should_skip_line:
+            continue
+        
+        for provider_name, pattern_regex in PROVIDER_PATTERNS:
+            pattern_matches = pattern_regex.finditer(line_content)
+            
+            for regex_match in pattern_matches:
+                potential_secret = regex_match.group(0)
+                
+                token_lowercase = potential_secret.lower()
+                has_safe_hint = False
+                
+                for safe_hint in SAFE_TEST_HINTS:
+                    if safe_hint in token_lowercase:
+                        has_safe_hint = True
+                        break
+                
+                if has_safe_hint:
+                    continue
+                
+                col_pos = line_content.find(potential_secret)
+                
+                finding = {
+                    "rule_id": "SKY-S101",
+                    "severity": "CRITICAL",
+                    "provider": provider_name,
+                    "message": f"Potential {provider_name} secret detected",
+                    "file": rel_path,
+                    "line": line_number,
+                    "col": max(0, col_pos),
+                    "end_col": max(1, col_pos + len(potential_secret)),
+                    "preview": _mask(potential_secret),
+                }
+                findings.append(finding)
+        
+        aws_key_indicators = ["AWS_SECRET_ACCESS_KEY", "aws_secret_access_key"]
+        line_has_aws_key = False
+        
+        for indicator in aws_key_indicators:
+            if indicator in line_content or indicator in line_content.lower():
+                line_has_aws_key = True
+                break
+        
+        if line_has_aws_key:
+            aws_secret_pattern = r"['\"]?([A-Za-z0-9/+=]{40})['\"]?"
+            aws_match = re.search(aws_secret_pattern, line_content)
+            
+            if aws_match:
+                aws_token = aws_match.group(1)
+                tok_entropy = _entropy(aws_token)
+                
+                if tok_entropy >= min_entropy:
+                    col_pos = line_content.find(aws_token)
+                    
+                    aws_finding = {
+                        "rule_id": "SKY-S101",
+                        "severity": "CRITICAL",
+                        "provider": "aws_secret_access_key",
+                        "message": "Potential AWS secret access key detected",
+                        "file": rel_path,
+                        "line": line_number,
+                        "col": max(0, col_pos),
+                        "end_col": max(1, col_pos + len(aws_token)),
+                        "preview": _mask(aws_token),
+                        "entropy": round(tok_entropy, 2),
+                    }
+                    findings.append(aws_finding)
+        
+        generic_match = GENERIC_VALUE.search(line_content)
+        if generic_match:
+            val_group = generic_match.group("val")
+            bare_group = generic_match.group("bare")
+            
+            if val_group:
+                extracted_token = val_group
+            elif bare_group:
+                extracted_token = bare_group
+            else:
+                extracted_token = ""
+            
+            clean_token = extracted_token.strip()
+            
+            if clean_token:
+                token_lowercase = clean_token.lower()
+                has_safe_hint = False
+                
+                for safe_hint in SAFE_TEST_HINTS:
+                    if safe_hint in token_lowercase:
+                        has_safe_hint = True
+                        break
+                
+                if not has_safe_hint:
+                    tok_entropy = _entropy(clean_token)
+                    
+                    if tok_entropy >= min_entropy and len(clean_token) >= 20:
+                        col_pos = line_content.find(clean_token)
+                        
+                        generic_finding = {
+                            "rule_id": "SKY-S101",
+                            "severity": "CRITICAL",
+                            "provider": "generic",
+                            "message": f"High-entropy value detected (entropy={tok_entropy:.2f})",
+                            "file": rel_path,
+                            "line": line_number,
+                            "col": max(0, col_pos),
+                            "end_col": max(1, col_pos + len(clean_token)),
+                            "preview": _mask(clean_token),
+                            "entropy": round(tok_entropy, 2),
+                        }
+                        findings.append(generic_finding)
+    
+    return findings

skylos/server.py

@@ -1,9 +1,3 @@
-#!/usr/bin/env python3
-"""
-Skylos Web Server
-Serves the frontend and provides API to analyze projects using skylos
-"""
-
 from flask import Flask, request, jsonify
 from flask_cors import CORS
 import skylos
@@ -17,7 +11,6 @@ CORS(app)
 
 @app.route('/')
 def serve_frontend():
-    """Serve the frontend HTML"""
     return """<!DOCTYPE html>
 <html lang="en">
 <head>
@@ -461,7 +454,6 @@ def serve_frontend():
                 classes: analysisData.unused_classes || []
             };
 
-            // Filter by confidence threshold
             Object.keys(data).forEach(key => {
                 data[key] = data[key].filter(item => item.confidence >= confidenceThreshold);
             });
@@ -481,12 +473,11 @@ def serve_frontend():
             const listElement = document.getElementById('deadCodeList');
             const allItems = [];
 
-            // Combine all items with their categories
             Object.keys(data).forEach(category => {
                 data[category].forEach(item => {
                     allItems.push({
                         ...item,
-                        category: category.slice(0, -1) // Remove 's' from end
+                        category: category.slice(0, -1)
                     });
                 });
             });
@@ -500,7 +491,6 @@ def serve_frontend():
                 return;
             }
 
-            // Sort by confidence (highest first)
             allItems.sort((a, b) => b.confidence - a.confidence);
 
             listElement.innerHTML = allItems.map(item => `
@@ -551,7 +541,6 @@ def start_server():
     print(" Starting Skylos Web Interface...")
     print("Opening browser at: http://localhost:5090")
     
-    # Open browser after a short delay
     Timer(1.5, open_browser).start()
     
     app.run(debug=False, host='0.0.0.0', port=5090, use_reloader=False)

skylos/visitor.py

@@ -3,13 +3,15 @@ import ast
 from pathlib import Path
 import re
 
-PYTHON_BUILTINS={"print", "len", "str", "int", "float", "list", "dict", "set", "tuple", "range", "open", 
+PYTHON_BUILTINS={"print", "len", "str", "int", "float", "list", "dict", "set", "tuple", "range", "open", "reversed", 
                  "super", "object", "type", "enumerate", "zip", "map", "filter", "sorted", "sum", "min", 
                 "next", "iter", "bytes", "bytearray", "format", "round", "abs", "complex", "hash", "id", "bool", "callable", 
                 "getattr", "max", "all", "any", "setattr", "hasattr", "isinstance", "globals", "locals", 
                 "vars", "dir" ,"property", "classmethod", "staticmethod"}
 DYNAMIC_PATTERNS={"getattr", "globals", "eval", "exec"}
 
+## "🥚" hi :) 
+
 class Definition:
     
     def __init__(self, name, t, filename, line):
@@ -60,9 +62,17 @@ class Visitor(ast.NodeVisitor):
         self.local_var_maps = []
         self.in_cst_class = 0
         self.local_type_maps = []
+        self._dataclass_stack = [] 
+        self.dataclass_fields = set()
+        self.first_read_lineno = {} 
 
     def add_def(self, name, t, line):
-        if name not in {d.name for d in self.defs}:
+        found = False
+        for d in self.defs:
+            if d.name == name:
+                found = True
+                break
+        if not found:
             self.defs.append(Definition(name, t, self.file, line))
 
     def add_ref(self, name):
@@ -72,8 +82,23 @@ class Visitor(ast.NodeVisitor):
         if name in self.alias:
             return self.alias[name]
         if name in PYTHON_BUILTINS:
+            if self.mod:
+                mod_candidate = f"{self.mod}.{name}"
+            else:
+                mod_candidate = name
+            if any(d.name == mod_candidate for d in self.defs):
+                return mod_candidate
+            
+        if self.mod:
+            return f"{self.mod}.{name}"
+        else:
             return name
-        return f"{self.mod}.{name}" if self.mod else name
+    
+    def visit_Global(self, node):
+        if self.current_function_scope and self.local_var_maps:
+            for name in node.names:
+                self.local_var_maps[-1][name] = f"{self.mod}.{name}"
+        return
 
     def visit_annotation(self, node):
         if node is not None:
@@ -148,7 +173,11 @@ class Visitor(ast.NodeVisitor):
         
         qualified_name= ".".join(filter(None, name_parts))
 
-        self.add_def(qualified_name,"method"if self.cls else"function",node.lineno)
+        if self.cls:
+            def_type = "method"
+        else:
+            def_type = "function"
+        self.add_def(qualified_name, def_type, node.lineno)
         
         self.current_function_scope.append(node.name)
         self.local_var_maps.append({})
@@ -183,19 +212,41 @@ class Visitor(ast.NodeVisitor):
         self.add_def(cname, "class",node.lineno)
         
         is_cst = False
-        
+        is_dc  = False
+
         for base in node.bases:
             base_name = ""
+
             if isinstance(base, ast.Attribute):
                 base_name = base.attr
+                
             elif isinstance(base, ast.Name):
                 base_name = base.id
             self.visit(base)
+
             if base_name in {"CSTTransformer", "CSTVisitor"}:
                 is_cst = True
+                
         for keyword in node.keywords:
             self.visit(keyword.value)
+
         for decorator in node.decorator_list:
+            def _is_dc(dec):
+                if isinstance(dec, ast.Call):
+                    target = dec.func
+                else:
+                    target = dec
+
+                if isinstance(target, ast.Name):
+                    return target.id == "dataclass"
+                
+                if isinstance(target, ast.Attribute):
+                    return target.attr == "dataclass"
+                
+                return False
+            
+            if _is_dc(decorator):
+                is_dc = True
             self.visit(decorator)
         
         prev= self.cls
@@ -203,10 +254,13 @@ class Visitor(ast.NodeVisitor):
             self.in_cst_class += 1
 
         self.cls= node.name
+        self._dataclass_stack.append(is_dc)
         for b in node.body:
             self.visit(b)
 
         self.cls= prev
+        self._dataclass_stack.pop()
+    
         if is_cst:
             self.in_cst_class -= 1
 
@@ -220,6 +274,7 @@ class Visitor(ast.NodeVisitor):
                 name_simple = t.id
                 scope_parts = [self.mod]
                 if self.cls: scope_parts.append(self.cls)
+
                 if self.current_function_scope: scope_parts.extend(self.current_function_scope)
                 prefix = '.'.join(filter(None, scope_parts))
                 if prefix:
@@ -228,9 +283,16 @@ class Visitor(ast.NodeVisitor):
                     var_name = name_simple
 
                 self.add_def(var_name, "variable", t.lineno)
+                if (self._dataclass_stack and self._dataclass_stack[-1] 
+                    and self.cls 
+                    and not self.current_function_scope):
+                    self.dataclass_fields.add(var_name)
+
                 if self.current_function_scope and self.local_var_maps:
                     self.local_var_maps[-1][name_simple] = var_name
+
             elif isinstance(t, (ast.Tuple, ast.List)):
+
                 for elt in t.elts:
                     _define(elt)
         _define(node.target)
@@ -243,19 +305,24 @@ class Visitor(ast.NodeVisitor):
                 self.local_var_maps and 
                 nm in self.local_var_maps[-1]):
 
-                self.add_ref(self.local_var_maps[-1][nm])
+                # self.add_ref(self.local_var_maps[-1][nm])
+                fq = self.local_var_maps[-1][nm]
+                self.add_ref(fq)
+                var_name = fq
 
             else:
                 self.add_ref(self.qual(nm))
-            scope_parts = [self.mod]
-            if self.cls: scope_parts.append(self.cls)
+                scope_parts = [self.mod]
+                if self.cls: 
+                    scope_parts.append(self.cls)
 
-            if self.current_function_scope: scope_parts.extend(self.current_function_scope)
-            prefix = '.'.join(filter(None, scope_parts))
-            if prefix:
-                var_name = f"{prefix}.{nm}"
-            else:
-                var_name = nm
+                if self.current_function_scope: 
+                    scope_parts.extend(self.current_function_scope)
+                prefix = '.'.join(filter(None, scope_parts))
+                if prefix:
+                    var_name = f"{prefix}.{nm}"
+                else:
+                    var_name = nm
 
             self.add_def(var_name, "variable", node.lineno)
             if self.current_function_scope and self.local_var_maps:
@@ -292,14 +359,19 @@ class Visitor(ast.NodeVisitor):
                 if self.current_function_scope:
                     scope_parts.extend(self.current_function_scope)
 
-                prefix = '.'.join(filter(None, scope_parts))
-                if prefix:
-                    var_name = f"{prefix}.{name_simple}"
+                if (self.current_function_scope and self.local_var_maps 
+                        and name_simple in self.local_var_maps[-1]):
+                    var_name = self.local_var_maps[-1][name_simple]
                 else:
-                    var_name = name_simple
+                    prefix = '.'.join(filter(None, scope_parts))
+                    if prefix:
+                        var_name = f"{prefix}.{name_simple}"
+                    else:
+                        var_name = name_simple
 
                 self.add_def(var_name, "variable", target_node.lineno)
-                if self.current_function_scope and self.local_var_maps:
+                if (self.current_function_scope and self.local_var_maps 
+                        and name_simple not in self.local_var_maps[-1]):
                     self.local_var_maps[-1][name_simple] = var_name
 
             elif isinstance(target_node, (ast.Tuple, ast.List)):
@@ -403,18 +475,19 @@ class Visitor(ast.NodeVisitor):
         if isinstance(node.ctx, ast.Load):
             for param_name, param_full_name in self.current_function_params:
                 if node.id == param_name:
+                    self.first_read_lineno.setdefault(param_full_name, node.lineno)
                     self.add_ref(param_full_name)
                     return
             
-            if (self.current_function_scope and 
-                self.local_var_maps 
-                and self.local_var_maps 
+            if (self.current_function_scope and self.local_var_maps
                 and node.id in self.local_var_maps[-1]):
-
-                self.add_ref(self.local_var_maps[-1][node.id])
+                fq = self.local_var_maps[-1][node.id]
+                self.first_read_lineno.setdefault(fq, node.lineno)
+                self.add_ref(fq)
                 return
             
             qualified = self.qual(node.id)
+            self.first_read_lineno.setdefault(qualified, node.lineno)
             self.add_ref(qualified)
             if node.id in DYNAMIC_PATTERNS:
                 self.dyn.add(self.mod.split(".")[0])

{skylos-2.1.1.dist-info → skylos-2.2.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: skylos
-Version: 2.1.1
+Version: 2.2.2
 Summary: A static analysis tool for Python codebases
 Author-email: oha <aaronoh2015@gmail.com>
 Requires-Python: >=3.9

{skylos-2.1.1.dist-info → skylos-2.2.2.dist-info}/RECORD

@@ -1,23 +1,28 @@
-skylos/__init__.py,sha256=vXBgYBrUqN3o2LxNCrT2pUVGS-Dnnkcakw7jItvQjXA,151
-skylos/analyzer.py,sha256=JoQ_otvLmI5k64y3h11jVZEWuA6u3npY15Nwy1vrGi0,14995
-skylos/cli.py,sha256=bRxhvKkw_VWQVHT6WxKyX9i3qJjGuJJaEJ3QI8FIpZw,15887
-skylos/codemods.py,sha256=A5dNwTJiYtgP3Mv8NQ03etdfi9qNHSECv1GRpLyDCYU,3213
-skylos/constants.py,sha256=vAfKls0OuR5idtXzeMDfYv5-wLtYWDe1NW5TSUJT8RI,1636
-skylos/framework_aware.py,sha256=eX4oU0jQwDWejkkW4kjRNctre27sVLHK1CTDDiqPqRw,13054
-skylos/server.py,sha256=5Rlgy3LdE8I5TWRJJh0n19JqhVYaAOc9fUtRjL-PpX8,16270
-skylos/test_aware.py,sha256=kxYoMG2m02kbMlxtFOM-MWJO8qqxHviP9HgAMbKRfvU,2304
-skylos/visitor.py,sha256=i-YWVenc8mG0dWzYi945HmktIE2RkgL7rBT7VUnhkLI,18073
+skylos/__init__.py,sha256=C4oz_FAjQTq_0XiSSxpDnngdL9YlWLpuam7NNvB_vPs,229
+skylos/analyzer.py,sha256=G_8pw7GmChATc5h5XXij2pcHirhh_5G9Y8dlAC1dx38,16735
+skylos/cli.py,sha256=DOV6nwPbi5zh-OJ3wXjIaPxCfXRtiPMNqo9Zp2nvDBA,19475
+skylos/codemods.py,sha256=QdOwtbE2PpLsgCqpeScFg-pCfcpfHw9hFu-0WKKKBQg,9084
+skylos/constants.py,sha256=kU-2FKQAV-ju4rYw62Tw25uRvqauzjZFUqtvGWaI6Es,1571
+skylos/server.py,sha256=oHuevjdDFvJVbvpTtCDjSLOJ6Zy1jL4BYLYV4VFNMXs,15903
+skylos/visitor.py,sha256=o_2JxjXKXAcWLQr8nmoatGAz2EhBk225qE_piHf3hDg,20458
+skylos/rules/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+skylos/rules/secrets.py,sha256=FD7cXZ4_Zfg_Si1qFXLVK-5OIX1HXtCr_yJM0OlRsbI,9425
+skylos/visitors/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+skylos/visitors/framework_aware.py,sha256=eX4oU0jQwDWejkkW4kjRNctre27sVLHK1CTDDiqPqRw,13054
+skylos/visitors/test_aware.py,sha256=kxYoMG2m02kbMlxtFOM-MWJO8qqxHviP9HgAMbKRfvU,2304
 test/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 test/compare_tools.py,sha256=0g9PDeJlbst-7hOaQzrL4MiJFQKpqM8q8VeBGzpPczg,22738
 test/conftest.py,sha256=57sTF6vLL5U0CVKwGQFJcRs6n7t1dEHIriQoSluNmAI,6418
 test/diagnostics.py,sha256=ExuFOCVpc9BDwNYapU96vj9RXLqxji32Sv6wVF4nJYU,13802
-test/test_analyzer.py,sha256=vZ-0cSF_otm7ZYdp6U3a8eWGwRZ6Tf0tVuJxYqcxdqM,22816
+test/test_analyzer.py,sha256=WhEYSI1atRee2Gqd9-Edw6F-tdRS9DBqS0D0aqK6MKc,21093
 test/test_changes_analyzer.py,sha256=l1hspCFz-sF8gqOilJvntUDuGckwhYsVtzvSRB13ZWw,5085
 test/test_cli.py,sha256=rtdKzanDRJT_F92jKkCQFdhvlfwVJxfXKO8Hrbn-mIg,13180
 test/test_codemods.py,sha256=Tbp9jE95HDl77EenTmyTtB1Sc3L8fwY9xiMNVDN5lxo,4522
 test/test_constants.py,sha256=pMuDy0UpC81zENMDCeK6Bqmm3BR_HHZQSlMG-9TgOm0,12602
 test/test_framework_aware.py,sha256=G9va1dEQ31wsvd4X7ROf_1YhhAQG5CogB7v0hYCojQ8,8802
 test/test_integration.py,sha256=bNKGUe-w0xEZEdnoQNHbssvKMGs9u9fmFQTOz1lX9_k,12398
+test/test_new_behaviours.py,sha256=vAON8rR09RXawZT1knYtZHseyRcECKz5bdOspJoMjUA,1472
+test/test_secrets.py,sha256=rjC-iQD9s8U296PyHP0vMEjC6CC9mJwKiFj7Sm-xsuo,5711
 test/test_skylos.py,sha256=kz77STrS4k3Eez5RDYwGxOg2WH3e7zNZPUYEaTLbGTs,15608
 test/test_test_aware.py,sha256=VmbR_MQY0m941CAxxux8OxJHIr7l8crfWRouSeBMhIo,9390
 test/test_visitor.py,sha256=xAbGv-XaozKm_0WJJhr0hMb6mLaJcbPz57G9-SWkxFU,22764
@@ -28,8 +33,8 @@ test/sample_repo/sample_repo/commands.py,sha256=b6gQ9YDabt2yyfqGbOpLo0osF7wya8O4
 test/sample_repo/sample_repo/models.py,sha256=xXIg3pToEZwKuUCmKX2vTlCF_VeFA0yZlvlBVPIy5Qw,3320
 test/sample_repo/sample_repo/routes.py,sha256=8yITrt55BwS01G7nWdESdx8LuxmReqop1zrGUKPeLi8,2475
 test/sample_repo/sample_repo/utils.py,sha256=S56hEYh8wkzwsD260MvQcmUFOkw2EjFU27nMLFE6G2k,1103
-skylos-2.1.1.dist-info/METADATA,sha256=Sodf-ShJV4dS2Y0AC611OAO2WmQhZT6aYIz0w0Df6a8,314
-skylos-2.1.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-skylos-2.1.1.dist-info/entry_points.txt,sha256=zzRpN2ByznlQoLeuLolS_TFNYSQxUGBL1EXQsAd6bIA,43
-skylos-2.1.1.dist-info/top_level.txt,sha256=f8GA_7KwfaEopPMP8-EXDQXaqd4IbsOQPakZy01LkdQ,12
-skylos-2.1.1.dist-info/RECORD,,
+skylos-2.2.2.dist-info/METADATA,sha256=LfA3i21DFqm9HGGJLXEkSwkK1Adv-58LPnIAmwguvwQ,314
+skylos-2.2.2.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+skylos-2.2.2.dist-info/entry_points.txt,sha256=zzRpN2ByznlQoLeuLolS_TFNYSQxUGBL1EXQsAd6bIA,43
+skylos-2.2.2.dist-info/top_level.txt,sha256=f8GA_7KwfaEopPMP8-EXDQXaqd4IbsOQPakZy01LkdQ,12
+skylos-2.2.2.dist-info/RECORD,,