dissolve-python 0.3.0

A tool to dissolve deprecated calls in Python codebases
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114

# Dissolve Examples

This directory contains example Python packages that demonstrate how to use the `dissolve` library for deprecation management.

## Package Structure

- `library/` - A Python package with various `@replace_me` decorated functions demonstrating different deprecation patterns
- `consumer/` - A consumer package that uses the deprecated functions from the library
- `requirements.txt` - Dependencies needed to run the examples

## Demonstrated Features

The examples showcase all the deprecation patterns supported by dissolve:

### Basic Functions (`library/utils.py`)
- Simple function deprecation with replacement
- Functions with complex parameter transformations
- Functions with version metadata

### Async Functions (`library/async_ops.py`)
- Async function deprecation
- Async functions with parameter mapping

### Classes (`library/models.py`)
- Class deprecation with wrapper pattern
- Method deprecation within classes
- Property deprecation

### Class Methods and Static Methods (`library/processors.py`)
- `@classmethod` deprecation
- `@staticmethod` deprecation
- Methods with complex parameter transformations

### Attributes (`library/config.py`)
- Module-level constant deprecation
- Class attribute deprecation

### Magic Methods (`library/containers.py`)
- Magic method deprecation (e.g., `__len__`, `__str__`)

## Running the Examples

1. Install dissolve:
   ```bash
   pip install dissolve
   cargo install dissolve-python  # Optional: for better performance
   ```

2. Install example dependencies:
   ```bash
   cd example
   pip install -r requirements.txt
   ```

3. Run the consumer code to see deprecation warnings:
   ```bash
   python consumer/main.py
   ```

4. Check what can be migrated:
   ```bash
   dissolve info consumer/
   ```

5. Preview migration changes:
   ```bash
   dissolve migrate consumer/
   ```

6. Apply migrations:
   ```bash
   dissolve migrate --write consumer/
   ```

7. Check for deprecated functions in the library:
   ```bash
   dissolve check library/
   ```

8. Clean up deprecated functions (library maintainer workflow):
   ```bash
   # Preview what would be removed
   dissolve cleanup --before 2.0.0 library/
   
   # Actually remove deprecated functions
   dissolve cleanup --before 2.0.0 --write library/
   ```

## Expected Warnings

When running `consumer/main.py`, you should see deprecation warnings like:

```
DeprecationWarning: <function old_add at 0x...> has been deprecated since 1.0.0; use 'add(a, b)' instead
DeprecationWarning: <class OldDataProcessor at 0x...> has been deprecated since 2.0.0; use 'DataProcessor(data_source)' instead
```

## Migration Examples

The migration tool will transform code like:

```python
# Before migration
result = old_add(5, 3)
processor = OldDataProcessor("db://localhost")
data = await old_fetch_data("https://api.example.com")

# After migration
result = add(5, 3)  
processor = DataProcessor("db://localhost")
data = await fetch_data("https://api.example.com", timeout=30)
```

This demonstrates how dissolve can automatically update codebases to use new APIs while preserving functionality.