ChatGPT writes python code
I asked ChatGPT 4 to write me some useful python code. It took a bit of mentoring.
Me 1
Write me a python3 function that collects the modification date and creation date of all the files and directories in a tree as JSON data, and another routine to reset a tree to those same dates.
ChatGPT4 1
Here’s a Python script with two functions: collect_dates() and reset_dates(). The first function collects the modification and creation dates of all files and directories in a given tree, and outputs the data in a JSON format. The second function resets a tree to those same dates based on the JSON data.
import os
import json
import time
from pathlib import Path
def collect_dates(root_directory):
date_data = {}
for foldername, _, filenames in os.walk(root_directory):
folder_path = os.path.abspath(foldername)
folder_stats = os.stat(folder_path)
date_data[folder_path] = {
'modification_time': folder_stats.st_mtime,
'creation_time': folder_stats.st_ctime
}
for filename in filenames:
file_path = os.path.join(folder_path, filename)
file_stats = os.stat(file_path)
date_data[file_path] = {
'modification_time': file_stats.st_mtime,
'creation_time': file_stats.st_ctime
}
json_data = json.dumps(date_data, indent=4)
return json_data
def reset_dates(root_directory, json_data):
date_data = json.loads(json_data)
for foldername, _, filenames in os.walk(root_directory):
folder_path = os.path.abspath(foldername)
folder_dates = date_data.get(folder_path, None)
if folder_dates:
os.utime(folder_path, (folder_dates['modification_time'], folder_dates['creation_time']))
for filename in filenames:
file_path = os.path.join(folder_path, filename)
file_dates = date_data.get(file_path, None)
if file_dates:
os.utime(file_path, (file_dates['modification_time'], file_dates['creation_time']))
if __name__ == '__main__':
root_directory = 'your_directory_path_here'
json_data = collect_dates(root_directory)
with open('file_dates.json', 'w') as f:
f.write(json_data)
# ... do any changes to the directory tree
with open('file_dates.json', 'r') as f:
json_data = f.read()
reset_dates(root_directory, json_data)
Replace your_directory_path_here with the path of the directory tree you want to collect and reset dates for. The collect_dates() function will output the JSON data, and the reset_dates() function will reset the dates using the JSON data provided. The script also includes a simple example of saving and loading the JSON data from a file.
Me 2
Can you rewrite that using dictionary comprehensions, please.
ChatGPT4 2
Certainly! Here’s the script with the collect_dates() function using a dictionary comprehension to collect the dates of the files and directories:
import os
import json
from pathlib import Path
def collect_dates(root_directory):
date_data = {
os.path.abspath(entry.path): {
'modification_time': entry.stat().st_mtime,
'creation_time': entry.stat().st_ctime
}
for root, _, filenames in os.walk(root_directory)
for entry_name in [root] + filenames
for entry in [Path(os.path.join(root, entry_name))]
}
json_data = json.dumps(date_data, indent=4)
return json_data
def reset_dates(root_directory, json_data):
date_data = json.loads(json_data)
for foldername, _, filenames in os.walk(root_directory):
folder_path = os.path.abspath(foldername)
folder_dates = date_data.get(folder_path, None)
if folder_dates:
os.utime(folder_path, (folder_dates['modification_time'], folder_dates['creation_time']))
for filename in filenames:
file_path = os.path.join(folder_path, filename)
file_dates = date_data.get(file_path, None)
if file_dates:
os.utime(file_path, (file_dates['modification_time'], file_dates['creation_time']))
if __name__ == '__main__':
root_directory = 'your_directory_path_here'
json_data = collect_dates(root_directory)
with open('file_dates.json', 'w') as f:
f.write(json_data)
# ... do any changes to the directory tree
with open('file_dates.json', 'r') as f:
json_data = f.read()
reset_dates(root_directory, json_data)
The collect_dates() function now uses a nested dictionary comprehension to collect the dates for the root directories, subdirectories, and files. Note that the reset_dates() function remains unchanged as it is already quite efficient and doesn’t benefit from a dictionary comprehension. Remember to replace your_directory_path_here with the actual path of the directory tree you want to work with.
Me 3
Instead of using os.walk, can you write recursive routines that build and use a JSON structure that reflects the directory hierarchy.
ChatGPT4 3
Certainly! Here’s a script with recursive functions collect_dates() and reset_dates() that build and use a JSON structure reflecting the directory hierarchy:
import os
import json
from pathlib import Path
def collect_dates(path):
path = os.path.abspath(path)
entry = Path(path)
if entry.is_file():
file_stats = entry.stat()
return {
'path': path,
'type': 'file',
'modification_time': file_stats.st_mtime,
'creation_time': file_stats.st_ctime
}
elif entry.is_dir():
children = [collect_dates(os.path.join(path, child)) for child in os.listdir(path)]
folder_stats = entry.stat()
return {
'path': path,
'type': 'directory',
'modification_time': folder_stats.st_mtime,
'creation_time': folder_stats.st_ctime,
'children': children
}
def reset_dates(json_data):
path = json_data['path']
os.utime(path, (json_data['modification_time'], json_data['creation_time']))
if json_data['type'] == 'directory':
for child in json_data['children']:
reset_dates(child)
if __name__ == '__main__':
root_directory = 'your_directory_path_here'
date_data = collect_dates(root_directory)
json_data = json.dumps(date_data, indent=4)
with open('file_dates.json', 'w') as f:
f.write(json_data)
# ... do any changes to the directory tree
with open('file_dates.json', 'r') as f:
json_data = f.read()
date_data = json.loads(json_data)
reset_dates(date_data)
This script uses recursive functions to collect and reset the dates while also preserving the directory hierarchy in the JSON structure. The collect_dates() function returns a dictionary for each file and directory, and the reset_dates() function processes the JSON structure to reset the dates.
Remember to replace your_directory_path_here with the actual path of the directory tree you want to work with.
Me 4
Can you modify those routines to record just the name, not the full path.
ChatGPT4 4
Sure! Here’s the modified script that records just the name instead of the full path for the directory hierarchy:
import os
import json
from pathlib import Path
def collect_dates(parent_path, name):
path = os.path.abspath(os.path.join(parent_path, name))
entry = Path(path)
if entry.is_file():
file_stats = entry.stat()
return {
'name': name,
'type': 'file',
'modification_time': file_stats.st_mtime,
'creation_time': file_stats.st_ctime
}
elif entry.is_dir():
children = [collect_dates(path, child) for child in os.listdir(path)]
folder_stats = entry.stat()
return {
'name': name,
'type': 'directory',
'modification_time': folder_stats.st_mtime,
'creation_time': folder_stats.st_ctime,
'children': children
}
def reset_dates(parent_path, json_data):
path = os.path.abspath(os.path.join(parent_path, json_data['name']))
os.utime(path, (json_data['modification_time'], json_data['creation_time']))
if json_data['type'] == 'directory':
for child in json_data['children']:
reset_dates(path, child)
if __name__ == '__main__':
root_directory = 'your_directory_path_here'
root_name = os.path.basename(root_directory)
date_data = collect_dates(os.path.dirname(root_directory), root_name)
json_data = json.dumps(date_data, indent=4)
with open('file_dates.json', 'w') as f:
f.write(json_data)
# ... do any changes to the directory tree
with open('file_dates.json', 'r') as f:
json_data = f.read()
date_data = json.loads(json_data)
reset_dates(os.path.dirname(root_directory), date_data)
In this version of the script, the collect_dates() function takes two arguments: the parent path and the name of the entry. The function returns a dictionary with just the name for each file and directory. The reset_dates() function also takes two arguments: the parent path and the JSON data, and processes the JSON structure to reset the dates accordingly.
Remember to replace your_directory_path_here with the actual path of the directory tree you want to work with.
Me 5
Can you use a dict for the children instead of a list, and can you make the reset_dates routine return a tree of the differences it found. An empty dict would mean no changes. If a directory is not changed, but has modified children, it would not list its own dates, but just the modified children.
ChatGPT4 5
Sure! Here’s the modified script that uses a dictionary for the children and makes the reset_dates() function return a tree of the differences it found:
import os
import json
from pathlib import Path
def collect_dates(parent_path, name):
path = os.path.abspath(os.path.join(parent_path, name))
entry = Path(path)
if entry.is_file():
file_stats = entry.stat()
return {
'name': name,
'type': 'file',
'modification_time': file_stats.st_mtime,
'creation_time': file_stats.st_ctime
}
elif entry.is_dir():
children = {child: collect_dates(path, child) for child in os.listdir(path)}
folder_stats = entry.stat()
return {
'name': name,
'type': 'directory',
'modification_time': folder_stats.st_mtime,
'creation_time': folder_stats.st_ctime,
'children': children
}
def reset_dates(parent_path, json_data):
path = os.path.abspath(os.path.join(parent_path, json_data['name']))
entry = Path(path)
if not entry.exists():
return {json_data['name']: 'Not found'}
current_mtime = entry.stat().st_mtime
current_ctime = entry.stat().st_ctime
changes = {}
if json_data['type'] == 'file':
if current_mtime != json_data['modification_time'] or current_ctime != json_data['creation_time']:
os.utime(path, (json_data['modification_time'], json_data['creation_time']))
changes = {
'name': json_data['name'],
'type': 'file',
'old_modification_time': current_mtime,
'old_creation_time': current_ctime
}
elif json_data['type'] == 'directory':
for child_name, child_data in json_data['children'].items():
child_changes = reset_dates(path, child_data)
if child_changes:
changes[child_name] = child_changes
if changes:
if current_mtime != json_data['modification_time'] or current_ctime != json_data['creation_time']:
os.utime(path, (json_data['modification_time'], json_data['creation_time']))
changes.update({
'name': json_data['name'],
'type': 'directory',
'old_modification_time': current_mtime,
'old_creation_time': current_ctime
})
return changes
if __name__ == '__main__':
root_directory = 'your_directory_path_here'
root_name = os.path.basename(root_directory)
date_data = collect_dates(os.path.dirname(root_directory), root_name)
json_data = json.dumps(date_data, indent=4)
with open('file_dates.json', 'w') as f:
f.write(json_data)
# ... do any changes to the directory tree
with open('file_dates.json', 'r') as f:
json_data = f.read()
date_data = json.loads(json_data)
changes = reset_dates(os.path.dirname(root_directory), date_data)
print("Changes:", json.dumps(changes, indent=4))
In this version of the script, the collect_dates() function stores the children as a dictionary. The reset_dates() function returns a dictionary with the differences found in the directory tree. An empty dictionary means no changes, and if a directory is not changed but has modified children, it will not list its own dates but only the modified children.
Remember to replace your_directory_path_here with the actual path of the directory tree you want to work with.
Me 6
Can you add doc strings to the functions?
ChatGPT4 6
Sure! I’ve added docstrings to both the collect_dates() and reset_dates() functions to provide more information about their purpose and usage:
import os
import json
from pathlib import Path
def collect_dates(parent_path, name):
"""
Recursively collects the modification and creation dates of all files and directories
in the specified directory tree.
:param parent_path: str, the parent path of the current entry (file or directory)
:param name: str, the name of the current entry (file or directory)
:return: dict, a hierarchical dictionary representing the directory structure
"""
path = os.path.abspath(os.path.join(parent_path, name))
entry = Path(path)
if entry.is_file():
file_stats = entry.stat()
return {
'name': name,
'type': 'file',
'modification_time': file_stats.st_mtime,
'creation_time': file_stats.st_ctime
}
elif entry.is_dir():
children = {child: collect_dates(path, child) for child in os.listdir(path)}
folder_stats = entry.stat()
return {
'name': name,
'type': 'directory',
'modification_time': folder_stats.st_mtime,
'creation_time': folder_stats.st_ctime,
'children': children
}
def reset_dates(parent_path, json_data):
"""
Recursively resets the modification and creation dates of all files and directories
in the specified directory tree based on the provided JSON data.
:param parent_path: str, the parent path of the current entry (file or directory)
:param json_data: dict, the JSON data containing the original dates and directory structure
:return: dict, a dictionary representing the differences found in the directory tree
"""
path = os.path.abspath(os.path.join(parent_path, json_data['name']))
entry = Path(path)
if not entry.exists():
return {json_data['name']: 'Not found'}
current_mtime = entry.stat().st_mtime
current_ctime = entry.stat().st_ctime
changes = {}
if json_data['type'] == 'file':
if current_mtime != json_data['modification_time'] or current_ctime != json_data['creation_time']:
os.utime(path, (json_data['modification_time'], json_data['creation_time']))
changes = {
'name': json_data['name'],
'type': 'file',
'old_modification_time': current_mtime,
'old_creation_time': current_ctime
}
elif json_data['type'] == 'directory':
for child_name, child_data in json_data['children'].items():
child_changes = reset_dates(path, child_data)
if child_changes:
changes[child_name] = child_changes
if changes:
if current_mtime != json_data['modification_time'] or current_ctime != json_data['creation_time']:
os.utime(path, (json_data['modification_time'], json_data['creation_time']))
changes.update({
'name': json_data['name'],
'type': 'directory',
'old_modification_time': current_mtime,
'old_creation_time': current_ctime
})
return changes
if __name__ == '__main__':
root_directory = 'your_directory_path_here'
root_name = os.path.basename(root_directory)
date_data = collect_dates(os.path.dirname(root_directory), root_name)
json_data = json.dumps(date_data, indent=4)
with open('file_dates.json', 'w') as f:
f.write(json_data)
# ... do any changes to the directory tree
Me 7
Can you add type hints, please?
ChatGPT4 7
Certainly! Here’s the modified script with added type hints for both the collect_dates() and reset_dates() functions:
import os
import json
from pathlib import Path
from typing import Dict, Union
def collect_dates(parent_path: str, name: str) -> Dict[str, Union[str, float, Dict]]:
"""
Recursively collects the modification and creation dates of all files and directories
in the specified directory tree.
:param parent_path: str, the parent path of the current entry (file or directory)
:param name: str, the name of the current entry (file or directory)
:return: dict, a hierarchical dictionary representing the directory structure
"""
path = os.path.abspath(os.path.join(parent_path, name))
entry = Path(path)
if entry.is_file():
file_stats = entry.stat()
return {
'name': name,
'type': 'file',
'modification_time': file_stats.st_mtime,
'creation_time': file_stats.st_ctime
}
elif entry.is_dir():
children = {child: collect_dates(path, child) for child in os.listdir(path)}
folder_stats = entry.stat()
return {
'name': name,
'type': 'directory',
'modification_time': folder_stats.st_mtime,
'creation_time': folder_stats.st_ctime,
'children': children
}
def reset_dates(parent_path: str, json_data: Dict[str, Union[str, float, Dict]]) -> Dict[str, Union[str, Dict]]:
"""
Recursively resets the modification and creation dates of all files and directories
in the specified directory tree based on the provided JSON data.
:param parent_path: str, the parent path of the current entry (file or directory)
:param json_data: dict, the JSON data containing the original dates and directory structure
:return: dict, a dictionary representing the differences found in the directory tree
"""
path = os.path.abspath(os.path.join(parent_path, json_data['name']))
entry = Path(path)
if not entry.exists():
return {json_data['name']: 'Not found'}
current_mtime = entry.stat().st_mtime
current_ctime = entry.stat().st_ctime
changes = {}
if json_data['type'] == 'file':
if current_mtime != json_data['modification_time'] or current_ctime != json_data['creation_time']:
os.utime(path, (json_data['modification_time'], json_data['creation_time']))
changes = {
'name': json_data['name'],
'type': 'file',
'old_modification_time': current_mtime,
'old_creation_time': current_ctime
}
elif json_data['type'] == 'directory':
for child_name, child_data in json_data['children'].items():
child_changes = reset_dates(path, child_data)
if child_changes:
changes[child_name] = child_changes
if changes:
if current_mtime != json_data['modification_time'] or current_ctime != json_data['creation_time']:
os.utime(path, (json_data['modification_time'], json_data['creation_time']))
changes.update({
'name': json_data['name'],
'type': 'directory',
'old_modification_time': current_mtime,
'old_creation_time': current_ctime
})
return changes
if __name__ == '__main__':
root_directory = 'your_directory_path_here'
root_name = os.path.basename(root_directory)
date_data = collect_dates(os.path.dirname(root_directory), root_name)
json_data = json.dumps(date
Me 8
Can you make them accept either a string or a Path?
ChatGPT4 8
Sure! I’ve updated the collect_dates() and reset_dates() functions to accept either a str or a Path object for the parent_path parameter. Here’s the modified script:
import os
import json
from pathlib import Path
from typing import Dict, Union
def collect_dates(parent_path: Union[str, Path], name: str) -> Dict[str, Union[str, float, Dict]]:
"""
Recursively collects the modification and creation dates of all files and directories
in the specified directory tree.
:param parent_path: Union[str, Path], the parent path of the current entry (file or directory)
:param name: str, the name of the current entry (file or directory)
:return: dict, a hierarchical dictionary representing the directory structure
"""
parent_path = str(parent_path)
path = os.path.abspath(os.path.join(parent_path, name))
entry = Path(path)
if entry.is_file():
file_stats = entry.stat()
return {
'name': name,
'type': 'file',
'modification_time': file_stats.st_mtime,
'creation_time': file_stats.st_ctime
}
elif entry.is_dir():
children = {child: collect_dates(path, child) for child in os.listdir(path)}
folder_stats = entry.stat()
return {
'name': name,
'type': 'directory',
'modification_time': folder_stats.st_mtime,
'creation_time': folder_stats.st_ctime,
'children': children
}
def reset_dates(parent_path: Union[str, Path], json_data: Dict[str, Union[str, float, Dict]]) -> Dict[str, Union[str, Dict]]:
"""
Recursively resets the modification and creation dates of all files and directories
in the specified directory tree based on the provided JSON data.
:param parent_path: Union[str, Path], the parent path of the current entry (file or directory)
:param json_data: dict, the JSON data containing the original dates and directory structure
:return: dict, a dictionary representing the differences found in the directory tree
"""
parent_path = str(parent_path)
path = os.path.abspath(os.path.join(parent_path, json_data['name']))
entry = Path(path)
if not entry.exists():
return {json_data['name']: 'Not found'}
current_mtime = entry.stat().st_mtime
current_ctime = entry.stat().st_ctime
changes = {}
if json_data['type'] == 'file':
if current_mtime != json_data['modification_time'] or current_ctime != json_data['creation_time']:
os.utime(path, (json_data['modification_time'], json_data['creation_time']))
changes = {
'name': json_data['name'],
'type': 'file',
'old_modification_time': current_mtime,
'old_creation_time': current_ctime
}
elif json_data['type'] == 'directory':
for child_name, child_data in json_data['children'].items():
child_changes = reset_dates(path, child_data)
if child_changes:
changes[child_name] = child_changes
if changes:
if current_mtime != json_data['modification_time'] or current_ctime != json_data['creation_time']:
os.utime(path, (json_data['modification_time'], json_data['creation_time']))
changes.update({
'name': json_data['name'],
'type': 'directory',
'old_modification_time': current_mtime,
'old_creation_time': current_ctime
})
return changes
if __name__
Me 9
continue
ChatGPT4 9
Here’s the continued script:
== '__main__':
root_directory = 'your_directory_path_here'
root_name = os.path.basename(root_directory)
date_data = collect_dates(os.path.dirname(root_directory), root_name)
json_data = json.dumps(date_data, indent=4)
with open('file_dates.json', 'w') as f:
f.write(json_data)
# ... do any changes to the directory tree
# Load JSON data from the file
with open('file_dates.json', 'r') as f:
json_data = json.load(f)
# Reset the dates in the directory tree and collect the differences
differences = reset_dates(os.path.dirname(root_directory), json_data)
# Print the differences
print(json.dumps(differences, indent=4))
This is the complete script with the collect_dates() and reset_dates() functions modified to accept either a str or a Path object for the parent_path parameter. The main part of the script demonstrates how to use the functions to collect dates, save the data to a JSON file, and reset the dates based on the stored JSON data.
Me 10
It would be better to convert string arguments to Path objects rather than Path objects to strings. You can use Path.resolve() to get an absolute path, but you don’t need one since you’re not including the absolute path in the result. You can use the / operator to join to Path objects.
ChatGPT4 10
You’re right, it would be better to work with Path objects. I’ve updated the collect_dates() and reset_dates() functions to convert string arguments to Path objects and to use the / operator to join Path objects:
import os
import json
from pathlib import Path
from typing import Dict, Union
def collect_dates(parent_path: Union[str, Path], name: str) -> Dict[str, Union[str, float, Dict]]:
"""
Recursively collects the modification and creation dates of all files and directories
in the specified directory tree.
:param parent_path: Union[str, Path], the parent path of the current entry (file or directory)
:param name: str, the name of the current entry (file or directory)
:return: dict, a hierarchical dictionary representing the directory structure
"""
parent_path = Path(parent_path)
path = parent_path / name
entry = path
if entry.is_file():
file_stats = entry.stat()
return {
'name': name,
'type': 'file',
'modification_time': file_stats.st_mtime,
'creation_time': file_stats.st_ctime
}
elif entry.is_dir():
children = {child: collect_dates(path, child) for child in os.listdir(path)}
folder_stats = entry.stat()
return {
'name': name,
'type': 'directory',
'modification_time': folder_stats.st_mtime,
'creation_time': folder_stats.st_ctime,
'children': children
}
def reset_dates(parent_path: Union[str, Path], json_data: Dict[str, Union[str, float, Dict]]) -> Dict[str, Union[str, Dict]]:
"""
Recursively resets the modification and creation dates of all files and directories
in the specified directory tree based on the provided JSON data.
:param parent_path: Union[str, Path], the parent path of the current entry (file or directory)
:param json_data: dict, the JSON data containing the original dates and directory structure
:return: dict, a dictionary representing the differences found in the directory tree
"""
parent_path = Path(parent_path)
path = parent_path / json_data['name']
entry = path
if not entry.exists():
return {json_data['name']: 'Not found'}
current_mtime = entry.stat().st_mtime
current_ctime = entry.stat().st_ctime
changes = {}
if json_data['type'] == 'file':
if current_mtime != json_data['modification_time'] or current_ctime != json_data['creation_time']:
os.utime(path, (json_data['modification_time'], json_data['creation_time']))
changes = {
'name': json_data['name'],
'type': 'file',
'old_modification_time': current_mtime,
'old_creation_time': current_ctime
}
elif json_data['type'] == 'directory':
for child_name, child_data in json_data['children'].items():
child_changes = reset_dates(path, child_data)
if child_changes:
changes[child_name] = child_changes
if changes:
if current_mtime != json_data['modification_time'] or current_ctime != json_data['creation_time']:
os.utime(path, (json_data['modification_time'], json_data['creation_time']))
changes.update({
'name': json_data['name'],
'type': 'directory',
'old_modification_time': current_mtime,
'old_creation_time': current_ctime
})
return changes
if __name__ == '__main__':
Me 11
Continue
ChatGPT4 11
Here’s the continued script:
root_directory = 'your_directory_path_here'
root_name = os.path.basename(root_directory)
date_data = collect_dates(os.path.dirname(root_directory), root_name)
json_data = json.dumps(date_data, indent=4)
with open('file_dates.json', 'w') as f:
f.write(json_data)
# ... do any changes to the directory tree
# Load JSON data from the file
with open('file_dates.json', 'r') as f:
json_data = json.load(f)
# Reset the dates in the directory tree and collect the differences
differences = reset_dates(os.path.dirname(root_directory), json_data)
# Print the differences
print(json.dumps(differences, indent=4))
This is the complete script with the collect_dates() and reset_dates() functions updated to convert string arguments to Path objects and to use the / operator to join Path objects. The main part of the script demonstrates how to use the functions to collect dates, save the data to a JSON file, and reset the dates based on the stored JSON data.
Me 12
You can use a dict comprehension to collect the child changes, place them in a ‘children’ dict key. It should match the structure of the collect_dates routine. Also, the code for the changes to files and to directories is the same except for ‘type’ and the children, so can be consolidated. You can use a separate function if it helps, or a nested one.
ChatGPT4 12
I’ve updated the reset_dates() function to use a dictionary comprehension for collecting child changes and to consolidate the code for both files and directories. Here’s the updated function with a nested function called update_changes() to help with the consolidation:
def reset_dates(parent_path: Union[str, Path], json_data: Dict[str, Union[str, float, Dict]]) -> Dict[str, Union[str, Dict]]:
"""
Recursively resets the modification and creation dates of all files and directories
in the specified directory tree based on the provided JSON data.
:param parent_path: Union[str, Path], the parent path of the current entry (file or directory)
:param json_data: dict, the JSON data containing the original dates and directory structure
:return: dict, a dictionary representing the differences found in the directory tree
"""
parent_path = Path(parent_path)
path = parent_path / json_data['name']
entry = path
if not entry.exists():
return {json_data['name']: 'Not found'}
current_mtime = entry.stat().st_mtime
current_ctime = entry.stat().st_ctime
changes = {}
def update_changes():
nonlocal changes
if current_mtime != json_data['modification_time'] or current_ctime != json_data['creation_time']:
os.utime(path, (json_data['modification_time'], json_data['creation_time']))
changes = {
'name': json_data['name'],
'type': json_data['type'],
'old_modification_time': current_mtime,
'old_creation_time': current_ctime
}
if json_data['type'] == 'file':
update_changes()
elif json_data['type'] == 'directory':
child_changes = {child_name: reset_dates(path, child_data) for child_name, child_data in json_data['children'].items()}
child_changes = {k: v for k, v in child_changes.items() if v} # Filter out empty dictionaries
if child_changes:
changes['children'] = child_changes
update_changes()
return changes
This updated version of the reset_dates() function collects child changes in a ‘children’ key using a dictionary comprehension and uses the nested update_changes() function to consolidate the code for files and directories.
Me 13
You can avoid the use of nonlocal, and make the code a bit more clear, by making update_changes return the changes, or a dict with just ‘name’ and ‘type’ if no change, and then let the caller assign to changes, i.e. changes = update_changes(). This would also make your bug more obvious, where you set the ‘children’ key, then overwrite the hangers variable. The ‘file’ type can just return. The ‘changes variable is then scoped to just the last conditional. Assign it from update_changes(), and then add the child changes.
ChatGPT4 13
You’re right, returning the changes from the update_changes() function is a better approach, and it makes the code more clear. I’ve made the necessary adjustments to the reset_dates() function:
def reset_dates(parent_path: Union[str, Path], json_data: Dict[str, Union[str, float, Dict]]) -> Dict[str, Union[str, Dict]]:
"""
Recursively resets the modification and creation dates of all files and directories
in the specified directory tree based on the provided JSON data.
:param parent_path: Union[str, Path], the parent path of the current entry (file or directory)
:param json_data: dict, the JSON data containing the original dates and directory structure
:return: dict, a dictionary representing the differences found in the directory tree
"""
parent_path = Path(parent_path)
path = parent_path / json_data['name']
entry = path
if not entry.exists():
return {json_data['name']: 'Not found'}
current_mtime = entry.stat().st_mtime
current_ctime = entry.stat().st_ctime
def update_changes():
if current_mtime != json_data['modification_time'] or current_ctime != json_data['creation_time']:
os.utime(path, (json_data['modification_time'], json_data['creation_time']))
return {
'name': json_data['name'],
'type': json_data['type'],
'old_modification_time': current_mtime,
'old_creation_time': current_ctime
}
else:
return {
'name': json_data['name'],
'type': json_data['type']
}
if json_data['type'] == 'file':
return update_changes()
elif json_data['type'] == 'directory':
child_changes = {child_name: reset_dates(path, child_data) for child_name, child_data in json_data['children'].items()}
child_changes = {k: v for k, v in child_changes.items() if v} # Filter out empty dictionaries
changes = update_changes()
if child_changes:
changes['children'] = child_changes
return changes
In this updated version of the reset_dates() function, the update_changes() function now returns the changes, and the caller assigns the returned value to the changes variable. The ‘file’ type returns the changes directly, and the code for handling directory types has been updated to avoid overwriting the changes variable.
Me 14
You introduce ‘entry’, but ‘path’ is the same.
ChatGPT4 14
You are right, entry is redundant in this case, as it is the same as path. Here’s the updated reset_dates() function without the entry variable:
def reset_dates(parent_path: Union[str, Path], json_data: Dict[str, Union[str, float, Dict]]) ->