o U h3@s|dZddlZddlmZddlmZGdddeZGdd d eZd d Zd d Z ddZ dddZ ddZ dddZ dS)z!Sparse checkout pattern handling.N)fnmatch)ensure_dir_existsc@eZdZdZdS)SparseCheckoutConflictErrorzTRaised when local modifications would be overwritten by a sparse checkout operation.N__name__ __module__ __qualname____doc__r r k/var/www/html/construction_image-detection-poc/venv/lib/python3.10/site-packages/dulwich/sparse_patterns.pyrrc@r)BlobNotFoundErrorzKRaised when a requested blob is not found in the repository's object store.Nrr r r r r"rrcCs|rt||St||S)agDetermine which paths in the index should be included based on either a full-pattern match or a cone-mode approach. Args: repo: A path to the repository or a Repo object. lines: A list of pattern lines (strings) from sparse-checkout config. cone: A bool indicating cone mode. Returns: A set of included path strings. )compute_included_paths_conecompute_included_paths_full)repolinesconer r r determine_included_paths&s  rcCsNt|}|}t}|D]\}}|d}t||ddr$||q|S)aUse .gitignore-style parsing and matching to determine included paths. Each file path in the index is tested against the parsed sparse patterns. If it matches the final (most recently applied) positive pattern, it is included. Args: repo: A path to the repository or a Repo object. lines: A list of pattern lines (strings) from sparse-checkout config. Returns: A set of included path strings. utf-8F) path_is_dir)parse_sparse_patterns open_indexsetitemsdecodematch_gitignore_patternsadd)rrparsedindexincluded path_bytesentrypath_strr r r r8s   rc Csd}d}t}|D]!}|dkrd}q |dkrd}q |dr*|d}|r*||q |}t}|D].\} } | d} d| vrK|rJ|| q6| ddd} |r_| |vr^|| q6|| q6|S) aAImplement a simplified 'cone' approach for sparse-checkout. By default, this can include top-level files, exclude all subdirectories, and re-include specified directories. The logic is less comprehensive than Git's built-in cone mode (recursive vs parent) and is essentially an implementation of the recursive cone mode. Args: repo: A path to the repository or a Repo object. lines: A list of pattern lines (strings), typically including entries like "/*", "!/*/", or "/mydir/". Returns: A set of included path strings. F/*Tz!/*//rrr)r startswithstriprrrrsplit) rrinclude_top_levelexclude_subdirsreinclude_dirspatdr r!r"r#r$top_dirr r r rPs8       rFc s}fdd}t|D]\}}|d}||vr(|dn|d|||<q|t|D]\}}tj j|d}|j r}tj |r||sc|||rct d|dzt |Wq<tysYq<ty{Yq.local_modifications_existrFTzLocal modifications in zE would be overwritten by sparse checkout. Use force=True to override.zBlob z not found for .wbN)rget_blob_normalizerlistrrset_skip_worktreewriter1r2join skip_worktreer3rremoveIsADirectoryErrorFileNotFoundErrorr7r8r9rrdirnamer4r;) rincluded_pathsforcer rDr"r#r$r<r@r>r rBr apply_included_pathssP           rScCsg}|D]@}|}|r|drq|d}|r|dd}|d}|r,|dd}d}|dr;d}|dd}|||||fq|S) aParse pattern lines from a sparse-checkout file (.git/info/sparse-checkout). This simplified parser: 1. Strips comments (#...) and empty lines. 2. Returns a list of (pattern, is_negation, is_dir_only, anchored) tuples. These lines are similar to .gitignore patterns but are used for sparse-checkout logic. This function strips comments and blank lines, identifies negation, anchoring, and directory-only markers, and returns data suitable for matching. Example: ``line = "/*.txt" -> ("/.txt", False, False, True)`` ``line = "!/docs/" -> ("/docs/", True, True, True)`` ``line = "mydir/" -> ("mydir/", False, True, False)`` not anchored, no leading "/" Args: lines: A list of raw lines (strings) from the sparse-checkout file. Returns: A list of tuples (pattern, negation, dir_only, anchored), representing the essential details needed to perform matching. #!rNr&FT)r(r'endswithappend)rresultsraw_linelinenegationanchoreddir_onlyr r r rs"      rc Csd}|D]l\}}}}|o| }||kr|rqd} nd} |r?| s?||dkr)| } nt||dr4d} n |s?t|d|d} |r\| s\|dkrHq||krOd} n||drYd} nd} n| skt||pjt|d|} | rp| }q|S)aCheck whether a path is included based on .gitignore-style patterns. This is a simplified approach that: 1. Iterates over patterns in order. 2. If a pattern matches, we set the "include" state depending on negation. 3. Later matches override earlier ones. In a .gitignore sense, lines that do not start with '!' are "ignore" patterns, lines that start with '!' are "unignore" (re-include). But in sparse checkout, it's effectively reversed: a non-negation line is "include," negation is "exclude." However, many flows still rely on the same final logic: the last matching pattern decides "excluded" vs. "included." We'll interpret "include" as returning True, "exclude" as returning False. Each pattern can include negation (!), directory-only markers, or be anchored to the start of the path. The last matching pattern determines whether the path is ultimately included or excluded. Args: path_str: The path (string) to test. parsed_patterns: A list of (pattern, negation, dir_only, anchored) tuples as returned by parse_sparse_patterns. path_is_dir: Whether to treat the path as a directory (default False). Returns: True if the path is included by the last matching pattern, False otherwise. FTr&r%z*/)rr') r$parsed_patternsr is_includedpatternr\r^r]forbidden_pathmatchedr r r rs:   r)F)r r1rfiler ExceptionrrrrrrSrrr r r r s   9L1