ccfx 0.8.0__py3-none-any.whl → 1.0.0__py3-none-any.whl

ccfx/__init__.py

@@ -2,4 +2,4 @@ from .ccfx import *
 from .excel import *
 from .word import *
 from .mssqlConnection import *
-from .sqliteConnection import sqliteConnection
+from .sqliteConnection import sqliteConnection

ccfx/ccfx.py

@@ -14,7 +14,7 @@ import os, sys
 import glob
 import warnings
 from netCDF4 import Dataset
-from osgeo import gdal, osr
+from osgeo import gdal, ogr, osr
 import numpy
 from genericpath import exists
 import shutil
@@ -23,7 +23,6 @@ import pickle
 import time
 from shapely.geometry import box, Point
 import geopandas, pandas
-from osgeo import gdal, ogr, osr
 import py7zr
 import subprocess
 import multiprocessing
@@ -33,6 +32,8 @@ from concurrent.futures import ThreadPoolExecutor
 import math
 import requests
 from tqdm import tqdm
+import yt_dlp
+from typing import Optional
 
 # functions
 def listFiles(path: str, ext: str = None) -> list:
@@ -119,8 +120,8 @@ def getMp3Metadata(fn, imagePath=None):
             'year': "Unknown Year",
             'genre': "Unknown Genre"
         }
-    
     return metadata
+    
 
 def guessMimeType(imagePath):
     ext = os.path.splitext(imagePath.lower())[1]
@@ -130,6 +131,111 @@ def guessMimeType(imagePath):
         return 'image/png'
     return 'image/png'
 
+
+def downloadYoutubeVideo(url: str, dstDir: str, audioOnly: bool = False, cookiesFile: str = None, dstFileName: Optional[str] = None ) -> str:
+    """
+    Download from YouTube via yt-dlp.
+
+    Args:
+        url: YouTube URL
+        dstDir: output directory (created if missing)
+        audioOnly: if True, extract MP3
+        dstFileName: exact filename (with extension). If None, uses title.
+
+    Returns: Full path to downloaded file.
+    """
+    os.makedirs(dstDir, exist_ok=True)
+
+    if dstFileName is None:
+        template = os.path.join(dstDir, "%(title)s.%(ext)s")
+    else:
+        template = os.path.join(dstDir, dstFileName)
+
+    opts = {"outtmpl": template}
+
+    if cookiesFile:
+        opts["cookiefile"] = cookiesFile
+
+    if audioOnly:
+        opts.update({
+            "format": "bestaudio/best",
+            "postprocessors": [{
+                "key": "FFmpegExtractAudio",
+                "preferredcodec": "mp3",
+                "preferredquality": "192",
+            }],
+        })
+        
+    else:
+        # prefer a single MP4 file (progressive), fallback to any best if none
+        opts["format"] = "bestvideo[ext=mp4]+bestaudio[ext=m4a]/best[ext=mp4]/best"
+
+    with yt_dlp.YoutubeDL(opts) as ytdl:
+        info = ytdl.extract_info(url, download=True)
+
+    # determine final filename
+    if dstFileName:
+        final = dstFileName
+    else:
+        ext = "mp3" if audioOnly else info.get("ext", "mp4")
+        title = info.get("title", "video")
+        final = f"{title}.{ext}"
+
+    return os.path.join(dstDir, final)
+
+
+def parseYoutubePlaylist(playlistUrl: str) -> list[str]:
+    """
+    Return a list of full video URLs contained in a YouTube playlist.
+
+    Args:
+        playlistUrl: Full URL of the playlist (the one with &list=… or /playlist?list=…).
+
+    Returns:
+        List of video URLs in the order reported by YouTube.
+    """
+    opts = {
+        "quiet": True,
+        "extract_flat": "in_playlist",   # don’t recurse into each video
+    }
+
+    with yt_dlp.YoutubeDL(opts) as ytdl:
+        info = ytdl.extract_info(playlistUrl, download=False)
+
+    entries = info.get("entries", [])
+    return [f"https://www.youtube.com/watch?v={e['id']}" for e in entries if e.get("id")]
+
+
+def parseYoutubeChannelVideos(channelUrl: str, maxItems: Optional[int] = None) -> list[str]:
+    """
+    Return a list of video URLs published on a channel.
+
+    Args:
+        channelUrl: Any canonical channel URL, e.g.
+                    - https://www.youtube.com/@LinusTechTips
+                    - https://www.youtube.com/channel/UCXuqSBlHAE6Xw-yeJA0Tunw
+                    - https://www.youtube.com/c/NASA/videos
+        maxItems:   Optional hard limit. If None, returns every video the API exposes.
+
+    Returns:
+        List of video URLs, newest-first (YouTube’s default order).
+    """
+    opts = {
+        "quiet": True,
+        "extract_flat": True,      # treat the channel as one big “playlist”
+        "skip_download": True,
+    }
+
+    with yt_dlp.YoutubeDL(opts) as ytdl:
+        info = ytdl.extract_info(channelUrl, download=False)
+
+    entries = info.get("entries", [])
+    if maxItems is not None:
+        entries = entries[:maxItems]
+
+    return [f"https://www.youtube.com/watch?v={e['id']}" for e in entries if e.get("id")]
+
+
 def setMp3Metadata(fn, metadata, imagePath=None):
     '''
     This function takes a path to an mp3 and a metadata dictionary,
@@ -225,6 +331,39 @@ def deleteFile(filePath:str, v:bool = False) -> bool:
     
     return deleted
 
+
+def alert(message:str, server:str = "http://ntfy.sh", topic:str = "pythonAlerts", attachment:str = None, messageTitle:str = "info", priority:int = None, tags:list = [],  printIt:bool = True, v:bool = False) -> bool:
+    '''
+    This sends an alert to a given server in case you want to be notified of something
+    message         : the message to send
+    server          : the server to send the message to (default is http://ntfy.sh)
+    topic           : the topic to send the message to (default is pythonAlerts)
+    attachment      : a file to attach to the message (optional)
+    messageTitle    : the title of the message (optional, default is info)
+    priority        : the priority of the message (optional, default is None)
+    tags            : a list of tags to add to the message (optional, default is empty list)
+    printIt         : whether to print the message to the console (default is True)
+    v               : verbose (default is False, set to True to print debug info)
+
+    return: True if the alert was sent successfully, False otherwise
+    '''
+    print(message) if printIt else None; header_data = {}
+    if not messageTitle is None: header_data["Title"] = messageTitle
+    if not priority is None: header_data["Priority"] = priority
+    if not len(tags) == 0: header_data["Tags"] = ",".join(tags)
+
+    try:
+        if v: print(f"sending alert to {server}/{topic}")
+        if not attachment is None:
+            header_data["Filename"] = getFileBaseName(attachment)
+            requests.put( f"{server}/{topic}", data=open(attachment, 'rb'), headers=header_data )
+            return True
+        try: requests.post(f"{server}/{topic}",data=message, headers=header_data )
+        except: return False
+    except: return False
+    return True
+
+
 def deletePath(path:str, v:bool = False) -> bool:
     '''
     Delete a directory
@@ -258,7 +397,39 @@ def downloadChunk(url, start, end, path):
             if chunk:
                 f.write(chunk)
 
-def downloadFile(url, save_path, exists_action='resume', num_connections=5, v=True):
+
+def formatStringBlock(input_str, max_chars=70):
+    '''
+    This function takes a string and formats it into a block of text
+    with a maximum number of characters per line.
+
+    input_str: the string to format
+    max_chars: the maximum number of characters per line (default is 70)
+
+    '''
+    words = input_str.split(' ')
+    lines = []
+    current_line = ""
+
+    for word in words:
+        # If adding the next word to the current line would exceed the max_chars limit
+        if len(current_line) + len(word) > max_chars:
+            # Append current line to lines and start a new one
+            lines.append(current_line.strip())
+            current_line = word
+        else:
+            # Add the word to the current line
+            current_line += " " + word
+
+    # Append any remaining words
+    lines.append(current_line.strip())
+
+    return '\n'.join(lines)
+
+
+
+
+def downloadFile(url, save_path, exists_action='resume', num_connections=5, v=False):
     if v:
         print(f"\ndownloading {url}")
     fname = getFileBaseName(url, extension=True)
@@ -592,21 +763,45 @@ def renameNetCDFvariable(input_file: str, output_file: str, old_var_name: str, n
     except subprocess.CalledProcessError as e:
         print(f"Error: {e.stderr}")
 
-def compressTo7z(input_dir: str, output_file: str):
+
+def compressTo7z(input_dir: str, output_file: str, compressionLevel: int = 4, excludeExt: list = None, v: bool = False) -> None:
     """
     Compresses the contents of a directory to a .7z archive with maximum compression.
     
     :param input_dir: Path to the directory to compress
     :param output_file: Output .7z file path
+    :param compressionLevel: Compression level (0-9), default is 4 (maximum compression)
+    :param excludeExt: List of file extensions to exclude from compression
     """
+    if excludeExt is None:
+        excludeExt = []
+
     # Create the .7z archive with LZMA2 compression
-    with py7zr.SevenZipFile(output_file, 'w', filters=[{'id': py7zr.FILTER_LZMA2, 'preset': 9}]) as archive:
+    with py7zr.SevenZipFile(output_file, 'w', filters=[{'id': py7zr.FILTER_LZMA2, 'preset': compressionLevel}]) as archive:
         # Add each item in the input directory, avoiding the top-level folder in the archive
         for root, _, files in os.walk(input_dir):
             for file in files:
                 file_path = os.path.join(root, file)
+                
+                # Skip excluded file extensions
+                if any(file.endswith(ext) for ext in excludeExt):
+                    continue
                 # Add file to the archive with a relative path to avoid including the 'tmp' folder itself
                 archive.write(file_path, arcname=os.path.relpath(file_path, start=input_dir))
+    if v:
+        print(f"compressed {input_dir} to {output_file} with compression level {compressionLevel}.")
+
+
+def uncompress(inputFile: str, outputDir: str, v: bool = False) -> None:
+    """
+    Extracts an archive supported by py7zr (.7z, .zip, .tar, .tar.gz, .tar.bz2, .xz, .tar.xz) to outputDir.
+    inputFile: Path to the input archive file
+    outputDir: Directory where the contents will be extracted
+    v: Verbose flag to print extraction status (default is False)
+    """
+    if not exists(outputDir): createPath(outputDir)
+    with py7zr.SevenZipFile(inputFile, 'r') as archive: archive.extractall(path=outputDir)
+    if v: print(f"extracted {inputFile} to {outputDir}.")
 
 
 def moveDirectory(srcDir:str, destDir:str, v:bool = False) -> bool:
@@ -693,6 +888,21 @@ def clipRasterByExtent(inFile: str, outFile: str, bounds: tuple) -> str:
     ds = None
     return outFile
 
+
+def clipRasterByVector(inFile: str, outFile: str, vectorFile: str) -> str:
+    '''
+    Clips a raster using GDAL warp with a vector file
+    inFile: input raster path
+    outFile: output path
+    vectorFile: vector file path (e.g., shapefile or GeoJSON)
+    return: output path
+    '''
+    ds = gdal.Open(inFile)
+    gdal.Warp(outFile, ds, cutlineDSName=vectorFile, cropToCutline=True)
+    ds = None
+    return outFile
+
+
 def clipVectorByExtent(inFile: str, outFile: str, bounds: tuple) -> str:
     '''
     Clips a vector using GeoPandas

ccfx-1.0.0.dist-info/METADATA

@@ -0,0 +1,180 @@
+Metadata-Version: 2.4
+Name: ccfx
+Version: 1.0.0
+Summary: This package simplifies regular common actions for quick prototyping in a user friendly way
+Author-email: Celray James CHAWANDA <celray@chawanda.com>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/celray/ccfx
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: netCDF4
+Requires-Dist: yt_dlp
+Requires-Dist: gdal
+Requires-Dist: numpy
+Requires-Dist: shapely
+Requires-Dist: geopandas
+Requires-Dist: pandas
+Requires-Dist: xlsxwriter
+Requires-Dist: pyodbc
+Requires-Dist: sqlalchemy
+Requires-Dist: python-docx
+Requires-Dist: py7zr
+Requires-Dist: mutagen
+Requires-Dist: requests
+Requires-Dist: tqdm
+Dynamic: license-file
+
+# ccfx
+
+`ccfx` is a comprehensive Python package designed to streamline file and data management, geospatial analysis, NetCDF file processing, database interactions, document generation, and multimedia handling for rapid prototyping and development workflows.
+
+## Features
+
+1.  **File Management**:
+    *   List, delete, move, copy, and count files/directories.
+    *   Monitor file count over time.
+    *   Save, load, and manage Python variables via pickle serialization.
+    *   Compress directories to `.7z` archives.
+    *   Read/write text files with encoding support.
+    *   Download files from URLs with resume and multi-connection support.
+
+2.  **Geospatial Data Processing**:
+    *   Read, write, clip (by extent/feature), resample, reproject, merge, and rasterize raster data (GeoTIFF, NetCDF).
+    *   Read, write, and clip vector data (Shapefile, GeoPackage).
+    *   Create grids of polygons based on shapefile boundaries.
+    *   Convert coordinates between Coordinate Reference Systems (CRS).
+    *   Extract raster values at specific coordinates.
+    *   Convert point lists to GeoDataFrames.
+    *   Get vector layer bounds.
+
+3.  **NetCDF File Handling**:
+    *   List variables and dimensions.
+    *   Export NetCDF variables to GeoTIFF format (single or multiple bands).
+    *   Calculate sum and average maps from NetCDF data across multiple files.
+    *   Rename variables using CDO (if available).
+
+4.  **Database Connectivity**:
+    *   **MS SQL Server**: Connect, list databases/tables, read tables (including spatial data into GeoDataFrames), write DataFrames/GeoDataFrames to tables, drop tables.
+    *   **SQLite**: Connect, create/rename/drop tables, read tables (as dict, specific columns), insert data (rows, dicts, partial dicts), update values, dump tables to CSV.
+
+5.  **Document & Spreadsheet Handling**:
+    *   **Excel**: Create `.xlsx` files, add sheets, write data (including dates), set column widths, add scatter plot charts.
+    *   **Word**: Create `.docx` files, add headings, paragraphs (with alignment), list items, formatted text (bold/italic), images, page breaks, set margins.
+
+6.  **Multimedia & Web**:
+    *   Read and write MP3 metadata (ID3 tags), including album art.
+    *   Download videos/audio from YouTube using `yt-dlp`.
+
+7.  **Data Analysis & Utilities**:
+    *   Calculate timeseries statistics (NSE, KGE, PBIAS, LNSE, R2, RMSE, MAE, MSE, MAPE, alpha, beta) with resampling options.
+    *   Display dynamic progress bars.
+    *   Check system platform information.
+    *   Enable or disable warnings programmatically.
+    *   Set the working directory.
+
+## Installation
+
+Install `ccfx` via pip:
+```bash
+pip install ccfx
+```
+
+## Dependencies
+
+`ccfx` relies on the following libraries:
+
+*   **gdal**: For geospatial raster and vector data manipulation.
+*   **numpy**: For array processing and numerical operations.
+*   **pandas**: For data manipulation and analysis.
+*   **geopandas**: Extends pandas to handle geospatial vector data.
+*   **shapely**: Provides geometric objects and operations.
+*   **netCDF4**: For working with NetCDF files.
+*   **xlsxwriter**: For creating and writing Excel `.xlsx` files.
+*   **python-docx**: Enables creation and manipulation of Word `.docx` documents.
+*   **pyodbc**: Enables connectivity to databases through ODBC (e.g., MS SQL Server).
+*   **sqlalchemy**: Provides SQL toolkit and ORM features for database access (used with MS SQL).
+*   **py7zr**: For creating `.7z` archives.
+*   **mutagen**: For reading and writing MP3 metadata (ID3 tags).
+*   **requests**: For downloading files via HTTP.
+*   **tqdm**: For displaying progress bars.
+*   **yt-dlp**: For downloading YouTube content.
+*   **matplotlib** (Optional, often used with geospatial/data analysis): For plotting.
+
+These dependencies should be installed automatically when `ccfx` is installed via pip, but GDAL might require manual installation steps depending on your OS.
+
+## API Reference (Selected Functions)
+
+### File Management (`ccfx.py`)
+
+*   **`listFiles(path: str, ext: str = None) -> list`**: Lists files in a directory, optionally filtering by extension.
+*   **`deleteFile(filePath: str, v: bool = False) -> bool`**: Deletes a specified file.
+*   **`deletePath(path: str, v: bool = False) -> bool`**: Deletes a directory and its contents.
+*   **`createPath(pathName, v = False)`**: Creates a directory path if it doesn't exist.
+*   **`copyFile(source: str, destination: str, v: bool = True)`**: Copies a single file.
+*   **`copyDirectory(source: str, destination: str, recursive=True, v=True, filter=[])`**: Copies a directory's contents.
+*   **`moveDirectoryFiles(srcDir: str, destDir: str, v: bool = False) -> bool`**: Moves files and subdirectories from source to destination.
+*   **`pythonVariable(filename, option, variable=None)`**: Saves ('dump') or loads ('load') Python variables using pickle.
+*   **`compressTo7z(input_dir: str, output_file: str)`**: Compresses a directory into a .7z file.
+*   **`downloadFile(url, save_path, exists_action='resume', num_connections=5, v=False)`**: Downloads a file from a URL with advanced options.
+*   **`listAllFiles(folder, extension="*")`**: Recursively lists all files in a folder and its subfolders.
+
+### Geospatial (`ccfx.py`)
+
+*   **`createGrid(shapefile_path: str, resolution: float, useDegree: bool = True) -> tuple`**: Generates a grid of polygons based on a shapefile extent.
+*   **`clipRasterByExtent(inFile: str, outFile: str, bounds: tuple) -> str`**: Clips a raster using bounding box coordinates.
+*   **`clipVectorByExtent(inFile: str, outFile: str, bounds: tuple) -> str`**: Clips a vector file using bounding box coordinates.
+*   **`clipFeatures(inputFeaturePath:str, boundaryFeature:str, outputFeature:str, keepOnlyTypes = None, v = False) -> geopandas.GeoDataFrame`**: Clips input features by a boundary feature.
+*   **`resampleRaster(inFile:str, outFile:str, resolution:float, dstSRS = None, resamplingMethod = 'bilinear', replaceOutput:bool = True, v:bool = True) -> str`**: Resamples a raster to a new resolution and optionally CRS.
+*   **`reprojectRaster(inFile: str, outFile: str, dstProjection: str, resamplingMethod: str = 'mode') -> str`**: Reprojects a raster to a new CRS.
+*   **`mergeRasterTiles(tileList:list, outFile:str) -> str`**: Merges multiple raster files into one.
+*   **`rasterizeRaster(inFile: str, outFile: str, targetField: str, targetResolution: float) -> str`**: Rasterizes a vector layer based on an attribute field.
+*   **`extractRasterValue(rasterPath: str, lat: float, lon: float, coordProj: str = 'EPSG:4326') -> float`**: Extracts the raster value at a specific point.
+*   **`convertCoordinates(lon, lat, srcEPSG, dstCRS) -> tuple`**: Converts coordinates between CRSs.
+*   **`tiffWriteArray(array: numpy.ndarray, outputFile: str, geoTransform: tuple, projection: str, noData:float = None, v:bool = False) -> gdal.Dataset`**: Writes a NumPy array to a GeoTIFF file.
+*   **`pointsToGeodataframe(point_pairs_list, columns = ['latitude', 'longitude'], auth = "EPSG", code = '4326', out_shape = '', format = 'gpkg', v = False, get_geometry_only = False)`**: Converts a list of point coordinates to a GeoDataFrame.
+
+### NetCDF (`ccfx.py`)
+
+*   **`netcdfVariablesList(ncFile: str) -> list`**: Lists variables in a NetCDF file.
+*   **`netcdfVariableDimensions(ncFile: str, variable: str) -> dict`**: Gets dimensions and their sizes for a NetCDF variable.
+*   **`netcdfExportTif(ncFile: str, variable: str, outputFile: str = None, band: int = None, v:bool = True) -> gdal.Dataset`**: Exports a NetCDF variable (optionally a specific band) to GeoTIFF.
+*   **`netcdfAverageMap(ncFiles:list, variable:str, band:int = 1) -> numpy.ndarray`**: Calculates the average map from a variable across multiple NetCDF files.
+*   **`netcdfSumMaps(ncFiles:list, variable:str, band:int = 1) -> numpy.ndarray`**: Calculates the sum map from a variable across multiple NetCDF files.
+*   **`renameNetCDFvariable(input_file: str, output_file: str, old_var_name: str, new_var_name: str, v = False)`**: Renames a variable in a NetCDF file using CDO.
+
+### Database (`mssqlConnection.py`, `sqliteConnection.py`)
+
+*   **`mssql_connection(server, username, password, driver, ...)`**: Class for MS SQL Server interactions.
+    *   `connect()`, `listDatabases()`, `listTables()`, `readTable()`, `connectDB()`, `dataframeToSql()`, `dropTable()`, `close()`
+*   **`sqliteConnection(sqlite_database, connect=False)`**: Class for SQLite interactions.
+    *   `connect()`, `createTable()`, `renameTable()`, `deleteTable()`, `readTableAsDict()`, `insertDict()`, `insertRow()`, `updateValue()`, `dumpCSV()`, `commitChanges()`, `closeConnection()`
+
+### Document/Spreadsheet (`word.py`, `excel.py`)
+
+*   **`word_document(path)`**: Class for creating Word documents.
+    *   `addHeading()`, `addParagraph()`, `addListItem()`, `addText()`, `addImage()`, `addPageBreak()`, `setMargins()`, `save()`
+*   **`excel(path)`**: Class for creating Excel spreadsheets.
+    *   `create()`, `addSheet()`, `write()`, `writeDate()`, `setColumnWidth()`, `addFigure()`, `writeColumn()`, `save()`, `open()`
+
+### Multimedia & Web (`ccfx.py`)
+
+*   **`getMp3Metadata(fn, imagePath=None)`**: Extracts ID3 metadata from an MP3 file.
+*   **`setMp3Metadata(fn, metadata, imagePath=None)`**: Writes ID3 metadata (including album art) to an MP3 file.
+*   **`downloadYoutubeVideo(url: str, dstDir: str, audioOnly: bool = False, dstFileName: Optional[str] = None ) -> str`**: Downloads video or audio from a YouTube URL.
+
+### Data Analysis & Utilities (`ccfx.py`)
+
+*   **`calculateTimeseriesStats(data:pandas.DataFrame, observed:str = None, simulated:str = None, resample:str = None ) -> dict`**: Calculates various statistics between observed and simulated timeseries. (Wrappers like `getNSE`, `getKGE`, etc., are also available).
+*   **`progressBar(count, total, message="")`**: Displays a simple console progress bar.
+*   **`showProgress(count: int, end: int, message: str, barLength: int = 100)`**: Displays a more detailed console progress bar.
+*   **`ignoreWarnings(ignore:bool = True, v:bool = False)`**: Suppresses or enables Python warnings.
+
+## Contributing
+
+Contributions are welcome! Please fork the repository, make your changes, and submit a pull request. Ensure code is well-documented and includes tests where applicable.
+
+## License
+This project is licensed under the MIT License. See the LICENSE file for details.

ccfx-1.0.0.dist-info/RECORD

@@ -0,0 +1,11 @@
+ccfx/__init__.py,sha256=UK62VcGS84SJyGVg1bK4FltZj7OkpdoyhoFWeXcKsX0,144
+ccfx/ccfx.py,sha256=hUeU8i3v3Y5PTfHhAfXNeoRjacdeWrYUeznwArXsEOk,64046
+ccfx/excel.py,sha256=cQ4TQW49XqbMB3sSS0IOhO3-WArIolEBIrvOvhFyPtI,4757
+ccfx/mssqlConnection.py,sha256=TwyZXhHHI7zy6BSfH1pszuHVJ5cmndRC5dVxvEtSTks,7904
+ccfx/sqliteConnection.py,sha256=jEJ94D5ySt84N7AeDpa27Rclt1NaKhkX6nYzidwApIg,11104
+ccfx/word.py,sha256=AGa64jX5Zl5qotZh5L0QmrsjTnktIBhmj_ByRKZ88vw,3061
+ccfx-1.0.0.dist-info/licenses/LICENSE,sha256=EuxaawJg_OOCLfikkCGgfXPZmxR-x_5PH7_2e9M-3eA,1099
+ccfx-1.0.0.dist-info/METADATA,sha256=Uoy4Br0JKKZxW8cd9Bj-dguujuMX2CRRVbiZ_lk-8QQ,11260
+ccfx-1.0.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+ccfx-1.0.0.dist-info/top_level.txt,sha256=_cSvSA1WX2K8TgoV3iBJUdUZZqMKJbOPLNnKLYSLHaw,5
+ccfx-1.0.0.dist-info/RECORD,,

{ccfx-0.8.0.dist-info → ccfx-1.0.0.dist-info}/WHEEL

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

{ccfx-0.8.0.dist-info → ccfx-1.0.0.dist-info}/licenses/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2024 Celray James CHAWANDA
+Copyright (c) 2025 Celray James CHAWANDA
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
@@ -18,4 +18,4 @@ FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
+SOFTWARE.

ccfx-0.8.0.dist-info/METADATA

@@ -1,150 +0,0 @@
-Metadata-Version: 2.4
-Name: ccfx
-Version: 0.8.0
-Summary: This package simplifies regular common actions for quick prototyping in a user friendly way
-Author-email: Celray James CHAWANDA <celray@chawanda.com>
-License: MIT
-Project-URL: Homepage, https://github.com/celray/ccfx
-Classifier: Programming Language :: Python :: 3
-Classifier: License :: OSI Approved :: MIT License
-Classifier: Operating System :: OS Independent
-Requires-Python: >=3.10
-Description-Content-Type: text/markdown
-License-File: LICENSE
-Requires-Dist: netCDF4
-Requires-Dist: gdal
-Requires-Dist: numpy
-Requires-Dist: shapely
-Requires-Dist: geopandas
-Requires-Dist: pandas
-Requires-Dist: xlsxwriter
-Requires-Dist: pyodbc
-Requires-Dist: sqlalchemy
-Requires-Dist: python-docx
-Requires-Dist: py7zr
-Requires-Dist: mutagen
-Requires-Dist: requests
-Requires-Dist: tqdm
-Dynamic: license-file
-
-# ccfx
-
-`ccfx` is a comprehensive Python package designed to streamline file and data management, geospatial analysis, and NetCDF file processing for quick prototyping. The library provides versatile tools for file handling, raster and vector manipulation, database connectivity, and data export for geospatial and scientific computing projects.
-
-## Features
-
-1. **File Management**:
-   - List, delete, move, and count files within directories.
-   - Monitor file count over time in a specific directory.
-   - Save, load, and manage Python variables via pickle serialization.
-
-2. **Geospatial Data Processing**:
-   - Read, write, and manage raster and vector geospatial data.
-   - Clip rasters by bounding boxes and extract raster values at specified coordinates.
-   - Create grids of polygons based on shapefile boundaries with user-defined resolutions.
-   - Convert coordinates between coordinate reference systems (CRS).
-   - Write NumPy arrays to GeoTIFF files with projection and geotransform settings.
-
-3. **NetCDF File Handling**:
-   - List available variables and dimensions in NetCDF files.
-   - Export NetCDF variables to GeoTIFF format.
-   - Calculate sum and average maps from NetCDF data across multiple files.
-
-4. **Database Connectivity**:
-   - Access and interact with databases using ODBC and SQLAlchemy for flexible database management.
-   - Connect to both SQL Server and SQLite databases.
-
-5. **Progress Tracking and System Info**:
-   - Display dynamic progress bars for long-running operations.
-   - Check the system’s platform information.
-   - Enable or disable warnings programmatically.
-
-6. **Excel and Word File Handling**:
-   - Create and modify Excel files using xlsxwriter.
-   - Generate Word documents with advanced formatting options using python-docx.
-
-## Installation
-
-Install `ccfx` via pip:
-```bash
-pip install ccfx
-```
-
-## Dependencies
-
-`ccfx` relies on the following libraries:
-
-- **netCDF4**: For working with NetCDF files.
-- **gdal**: Required for geospatial raster data manipulation.
-- **numpy**: For array processing and numerical operations.
-- **pandas**: For data manipulation and analysis.
-- **shapely**: Provides geometric operations for spatial data.
-- **geopandas**: Extends pandas to handle geospatial data.
-- **xlsxwriter**: For creating and writing Excel files.
-- **pyodbc**: Enables connectivity to databases through ODBC.
-- **sqlalchemy**: Provides SQL toolkit and ORM features for database access.
-- **python-docx**: Enables creation and manipulation of Word documents.
-
-These dependencies will be installed automatically when `ccfx` is installed.
-
-## API Reference
-
-### `listFiles(path: str, ext: str = None) -> list`
-Lists all files in a directory with a specified extension.
-
-- **Parameters**:
-  - `path` (str): The directory to search.
-  - `ext` (str, optional): File extension to filter by, e.g., `'txt'`, `'.txt'`, `'*txt'`, or `'*.txt'`.
-
-- **Returns**:
-  - `list`: A list of file paths matching the criteria.
-
-### `deleteFile(filePath: str, v: bool = False) -> bool`
-Deletes a specified file with optional verbose output.
-
-- **Parameters**:
-  - `filePath` (str): Path to the file to be deleted.
-  - `v` (bool, optional): If `True`, prints a confirmation message. Defaults to `False`.
-
-- **Returns**:
-  - `bool`: `True` if deletion was successful; `False` otherwise.
-
-### `createGrid(shapefile_path: str, resolution: float, useDegree: bool = True) -> tuple`
-Generates a grid of polygons from a shapefile at a given resolution.
-
-- **Parameters**:
-  - `shapefile_path` (str): Path to the shapefile.
-  - `resolution` (float): Resolution of the grid.
-  - `useDegree` (bool, optional): If `True`, coordinates are in degrees. Defaults to `True`.
-
-- **Returns**:
-  - `tuple`: Contains grid coordinates and metadata.
-
-### `clipRasterByExtent(inFile: str, outFile: str, bounds: tuple) -> str`
-Clips a raster to specified bounding box coordinates.
-
-- **Parameters**:
-  - `inFile` (str): Path to the input raster file.
-  - `outFile` (str): Path to the output clipped raster file.
-  - `bounds` (tuple): Bounding box as `(minx, miny, maxx, maxy)`.
-
-- **Returns**:
-  - `str`: Path to the clipped raster file.
-
-### `netcdfVariablesList(ncFile: str) -> list`
-Lists all variables in a NetCDF file.
-
-- **Parameters**:
-  - `ncFile` (str): Path to the NetCDF file.
-
-- **Returns**:
-  - `list`: A list of variable names in the file.
-
-### ... And More ...
-
-## Contributing
-
-Contributions are welcome! Please fork the repository, make your changes, and submit a pull request.
-
-## License
-This project is licensed under the MIT License.

ccfx-0.8.0.dist-info/RECORD

@@ -1,11 +0,0 @@
-ccfx/__init__.py,sha256=VmBeF3oj6JTJ_793d4i8PvhyF8_FxaxA1L_FmHWqitc,142
-ccfx/ccfx.py,sha256=L0BeQLs4H9o8MlKlmr7pHqFmjbd5A3yDBKsk3XSzU5s,56313
-ccfx/excel.py,sha256=cQ4TQW49XqbMB3sSS0IOhO3-WArIolEBIrvOvhFyPtI,4757
-ccfx/mssqlConnection.py,sha256=TwyZXhHHI7zy6BSfH1pszuHVJ5cmndRC5dVxvEtSTks,7904
-ccfx/sqliteConnection.py,sha256=jEJ94D5ySt84N7AeDpa27Rclt1NaKhkX6nYzidwApIg,11104
-ccfx/word.py,sha256=AGa64jX5Zl5qotZh5L0QmrsjTnktIBhmj_ByRKZ88vw,3061
-ccfx-0.8.0.dist-info/licenses/LICENSE,sha256=2-M3fBUS3FmrSIrqd3cZDmxXxojWVJtZY-SHSRE6RxM,1098
-ccfx-0.8.0.dist-info/METADATA,sha256=1BskaEpbKDSaouiPDW9xdIlLdb62qPwwFjH2mUi9mpQ,5425
-ccfx-0.8.0.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
-ccfx-0.8.0.dist-info/top_level.txt,sha256=_cSvSA1WX2K8TgoV3iBJUdUZZqMKJbOPLNnKLYSLHaw,5
-ccfx-0.8.0.dist-info/RECORD,,