modulift 0.0.1__py3-none-any.whl

modulift/__init__.py

@@ -0,0 +1,3 @@
+from .api import *
+
+__version__ = '0.0.1'

modulift/api.py

@@ -0,0 +1,196 @@
+import pandas as pd
+from typing import List, Optional, Union
+from .data import load_data
+
+
+def search_by_keywords(*args: str, relation: str = "or", limit: Optional[int] = None, markdown: bool = False) -> List[dict]:
+    """
+    Search for keywords in the 'keywords' column with a specified relation ('or' or 'and') and optional limit on results.
+    
+    Parameters:
+    *args (str): Keywords to search for in the 'keywords' column.
+    relation (str, optional): Defines the logical relationship for keyword matching. 
+                              Use "or" for matching any keyword, and "and" for matching all keywords. 
+                              Defaults to "or".
+    limit (int, optional): The maximum number of results to return. Defaults to None, which returns all matches.
+    markdown (bool, optional): If True, prints the results in markdown format. Defaults to False.
+    
+    Returns:
+    List[dict]: A list of dictionaries with 'package', 'description', 'keywords', and 'popularity' fields 
+                for each row that matches the search criteria, sorted by 'popularity' in the specified order.
+    
+    Notes:
+    - The 'popularity' column is sorted in the order ['very popular', 'popular', 'not popular'].
+    - Markdown output is only printed and does not affect the returned result structure.
+
+    Example:
+    >>> search_by_keywords("machine learning", "data science", relation="and", limit=5, markdown=True)
+    [
+        {
+            'package': 'example-package',
+            'description': 'An example package for machine learning.',
+            'keywords': 'machine learning, data science, AI',
+            'popularity': 'very popular'
+        },
+        ...
+    ]
+    """
+    # Validate and normalize inputs
+    if not args:
+        raise ValueError("At least one keyword must be provided for search.")
+    
+    if relation not in {"or", "and"}:
+        raise ValueError("The 'relation' parameter must be either 'or' or 'and'.")
+    
+    if limit is not None and (not isinstance(limit, int) or limit <= 0):
+        raise ValueError("The 'limit' parameter must be a positive integer if specified.")
+    
+    # Load the DataFrame
+    df = load_data()
+    
+    # Convert the input keywords to a list
+    keywords = list(args)
+    
+    # Define the boolean mask based on 'or' or 'and' logic
+    if relation == "and":
+        mask = df['keywords'].apply(lambda cell: all(keyword.lower() in str(cell).lower() for keyword in keywords))
+    else:  # default to 'or' logic
+        mask = df['keywords'].apply(lambda cell: any(keyword.lower() in str(cell).lower() for keyword in keywords))
+    
+    # Filter the DataFrame with matching rows and select required columns
+    result_df = df[mask][['package', 'description', 'keywords', 'popularity']]
+    
+    # Define a custom order for sorting popularity
+    popularity_order = ['very popular', 'popular', 'not popular']
+    
+    # Sort the DataFrame by 'POPULARITY' based on the defined order
+    result_df['popularity'] = pd.Categorical(result_df['popularity'], categories=popularity_order, ordered=True)
+    result_df = result_df.sort_values('popularity')
+    
+    # Apply limit if specified
+    if limit is not None:
+        result_df = result_df.head(limit)
+    
+    # Convert to a list of dictionaries
+    results = result_df.to_dict(orient='records')
+    
+    # Print in markdown format if markdown is True
+    if markdown:
+        for i, row in enumerate(results, 1):
+            print(f"**{i}. {row['package']}**")
+            print(f"- **Description**: {row['description']}")
+            print(f"- **Keywords**: {row['keywords']}")
+            print(f"- **Popularity**: {row['popularity']}")
+            print("\n---\n")
+
+    return results
+
+def search_by_package_name(package_name: str, markdown: bool = False) -> Optional[dict]:
+    """
+    Search for an exact package name in the 'package' column of the DataFrame.
+    
+    Parameters:
+    package_name (str): The exact package name to search for.
+    markdown (bool, optional): If True, prints the result in markdown format. Defaults to False.
+    
+    Returns:
+    Optional[dict]: A dictionary with 'package', 'description', 'keywords', and 'popularity' fields if a match is found;
+                    otherwise, returns None.
+    
+    Example:
+    >>> search_by_package_name("example-package", markdown=True)
+    {
+        'package': 'example-package',
+        'description': 'An example package for data processing.',
+        'keywords': 'data processing, analysis, example',
+        'popularity': 'very popular'
+    }
+    """
+    if not isinstance(package_name, str) or not package_name.strip():
+        raise ValueError("The 'package_name' parameter must be a non-empty string.")
+
+    # Load the DataFrame
+    df = load_data()
+    
+    # Perform exact match search in the 'package' column
+    result_df = df[df['package'] == package_name][['package', 'description', 'keywords', 'popularity']]
+    
+    # Check if there is a match
+    if not result_df.empty:
+        result = result_df.iloc[0].to_dict()
+        
+        # Print in markdown format if markdown is True
+        if markdown:
+            print(f"**Package**: {result['package']}")
+            print(f"- **Description**: {result['description']}")
+            print(f"- **Keywords**: {result['keywords']}")
+            print(f"- **Popularity**: {result['popularity']}")
+            print("\n---\n")
+        
+        return result
+    else:
+        if markdown:
+            print(f"No match found for package name '{package_name}'.")
+        return None
+    
+    
+def search_by_description(text: str, limit: Optional[int] = None, markdown: bool = False) -> List[dict]:
+    """
+    Perform a full-text search in the 'description' column for a specific text, with an optional limit and markdown output.
+    
+    Parameters:
+    text (str): The text to search for in the 'description' column.
+    limit (int, optional): The maximum number of results to return. Defaults to None, which returns all matches.
+    markdown (bool, optional): If True, prints the results in markdown format. Defaults to False.
+    
+    Returns:
+    List[dict]: A list of dictionaries with 'package', 'description', 'keywords', and 'popularity' fields
+                for rows where the 'description' column contains the search text, limited by 'limit' if specified.
+    
+    Example:
+    >>> search_by_description("data analysis", limit=5, markdown=True)
+    [
+        {
+            'package': 'example-package',
+            'description': 'A package for data analysis and visualization.',
+            'keywords': 'data, analysis, visualization',
+            'popularity': 'very popular'
+        },
+        ...
+    ]
+    """
+    # Validate 'text' input
+    if not isinstance(text, str) or not text.strip():
+        raise ValueError("The 'text' parameter must be a non-empty string.")
+
+    # Validate 'limit' parameter
+    if limit is not None and (not isinstance(limit, int) or limit <= 0):
+        raise ValueError("The 'limit' parameter must be a positive integer if specified.")
+    
+    # Load the DataFrame
+    df = load_data()
+    
+    # Perform case-insensitive full-text search in the 'description' column
+    mask = df['description'].str.contains(text, case=False, na=False)
+    
+    # Filter the DataFrame with matching rows and select required columns
+    result_df = df[mask][['package', 'description', 'keywords', 'popularity']]
+    
+    # Apply limit if specified
+    if limit is not None:
+        result_df = result_df.head(limit)
+    
+    # Convert to a list of dictionaries
+    results = result_df.to_dict(orient='records')
+    
+    # Print in markdown format if markdown is True
+    if markdown:
+        for i, row in enumerate(results, 1):
+            print(f"**{i}. {row['package']}**")
+            print(f"- **Description**: {row['description']}")
+            print(f"- **Keywords**: {row['keywords']}")
+            print(f"- **Popularity**: {row['popularity']}")
+            print("\n---\n")
+    else:
+        print(f"No matches found for the text '{text}'.")
+    return results

modulift/data.py

@@ -0,0 +1,6 @@
+from datasets import load_dataset
+
+def load_data():
+    dataset = load_dataset("yeniguno/pypi")["train"]
+    df = dataset.to_pandas()
+    return df

modulift-0.0.1.dist-info/METADATA

@@ -0,0 +1,197 @@
+Metadata-Version: 2.1
+Name: modulift
+Version: 0.0.1
+Summary: A powerful search tool for discovering Python packages based on user queries
+Home-page: https://github.com/okanyenigun/modulift
+Author: Okan Yenigün
+Author-email: okanyenigun@gmail.com
+License: MIT
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+Classifier: Intended Audience :: Information Technology
+Classifier: Intended Audience :: Education
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: Software Development :: Documentation
+Classifier: Topic :: Scientific/Engineering :: Information Analysis
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+Requires-Dist: datasets==3.1.0
+Provides-Extra: dev
+Requires-Dist: twine==5.1.1; extra == "dev"
+Provides-Extra: test
+Requires-Dist: pytest==8.2.2; extra == "test"
+
+# Modulift
+
+**Modulift** is a powerful and efficient Python package designed to help developers, data scientists, and researchers explore and discover Python packages on PyPI based on specific keywords, package names, or full-text search within package descriptions. With a comprehensive dataset of PyPI packages, Modulift allows you to find relevant libraries for your project needs, making it an invaluable tool for anyone looking to streamline package selection and integration.
+
+## Key Features
+
+- **Exact Package Name Search**: Retrieve detailed information on a specific package by name.
+- **Keyword-Based Search**: Search packages by multiple keywords with flexible "or" and "and" logic to refine results.
+- **Full-Text Description Search**: Locate packages by searching for specific phrases or content in their descriptions.
+- **Markdown Output Option**: Print search results in Markdown format, ideal for documentation or presentations.
+
+## Installation
+
+Install Modulift via pip:
+
+```bash
+pip install modulift
+```
+
+## Usage
+
+Modulift provides an easy-to-use API for searching and exploring Python packages. Here’s a quick guide on how to use its core features.
+
+### 1. Search by Package Name
+
+Retrieve detailed information for a specific package by name:
+
+```python
+import modulift as mf
+
+result = mf.search_by_package_name("numpy")
+print(result)
+```
+
+**Output**:
+
+```python
+{
+    'package': 'numpy',
+    'description': 'NumPy is the fundamental package for scientific computing with Python. It provides powerful N-dimensional arrays, sophisticated mathematical functions, tools for integrating C/C++ and Fortran code, and useful linear algebra, Fourier transform, and random number capabilities.',
+    'keywords': 'scientific computing, array, linear algebra, Fourier transform, random number generation, data processing, numerical analysis',
+    'popularity': 'very popular'
+}
+```
+
+For a different package:
+
+```python
+result = mf.search_by_package_name("nullsweep")
+print(result)
+```
+
+**Output**:
+
+```python
+{
+    'package': 'nullsweep',
+    'description': 'NullSweep is a Python library designed for detecting and handling patterns of missing data in pandas DataFrames. It provides a simple API to identify global missing data patterns across the entire dataset, patterns related to specific features within the dataset, and to impute missing values using various strategies.',
+    'keywords': 'missing data, data imputation, pandas, pattern detection, feature-specific patterns',
+    'popularity': 'popular'
+}
+```
+
+Markdown Output
+To display the result in Markdown format:
+
+```python
+result = mf.search_by_package_name("numpy", markdown=True)
+```
+
+**Package**: numpy
+
+- **Description**: NumPy is the fundamental package for scientific computing with Python. It provides powerful N-dimensional arrays, sophisticated mathematical functions, tools for integrating C/C++ and Fortran code, and useful linear algebra, Fourier transform, and random number capabilities.
+- **Keywords**: scientific computing, array, linear algebra, Fourier transform, random number generation, data processing, numerical analysis
+- **Popularity**: very popular
+
+### 2. Search by Keywords
+
+Search for packages using one or more keywords. Modulift supports both "or" and "and" relations.
+
+Single Keyword Search
+
+```python
+result = mf.search_by_keywords("data science")
+print(len(result))
+```
+
+Output:
+
+```python
+3141  # Number of packages related to "data science"
+```
+
+Multi-Keyword Search with "and" Relation
+
+```python
+result = mf.search_by_keywords("data science", "machine learning", "deep learning", relation="and")
+print(len(result))
+```
+
+Output:
+
+```python
+115  # Number of packages related to all three keywords
+```
+
+Limiting Results with Markdown Output
+
+```python
+result = mf.search_by_keywords("data science", "machine learning", "deep learning", relation="and", limit=3, markdown=True)
+```
+
+Markdown Output
+
+**1. sagemaker**
+
+- **Description**: The SageMaker Python SDK is an open-source library designed for training and deploying machine learning models on Amazon SageMaker. It supports popular deep learning frameworks like Apache MXNet and TensorFlow, as well as Amazon's own scalable algorithms optimized for SageMaker. Users can also deploy custom algorithms in Docker containers, making it versatile for various machine learning tasks.
+- **Keywords**: machine learning, deep learning, model deployment, Amazon SageMaker, data science, AI, Docker
+- **Popularity**: very popular
+
+---
+
+**2. fastbook**
+
+- **Description**: fastbook is a comprehensive resource for learning deep learning through practical coding examples using the fastai library and PyTorch. It is designed for coders of all backgrounds, providing accessible education on deep learning techniques and applications across various domains, including computer vision and natural language processing.
+- **Keywords**: deep learning, fastai, PyTorch, computer vision, natural language processing, machine learning, data science, Jupyter Notebooks
+- **Popularity**: very popular
+
+---
+
+**3. ProAiLab**
+
+- **Description**: ProAiLab is a Python library designed for building and deploying AI models. It provides tools for data preprocessing, model training, and evaluation, making it suitable for both beginners and experienced machine learning practitioners.
+- **Keywords**: machine learning, AI, deep learning, data science, model development
+- **Popularity**: popular
+
+### 3. Full-Text Search in Descriptions
+
+Search for packages based on specific phrases within the description.
+
+```python
+result = mf.search_by_description("training and deploying machine learning models on Amazon", markdown=True)
+```
+
+Markdown Output
+
+**1. sagemaker**
+
+- **Description**: The SageMaker Python SDK is an open-source library designed for training and deploying machine learning models on Amazon SageMaker. It supports popular deep learning frameworks like Apache MXNet and TensorFlow, as well as Amazon's own scalable algorithms optimized for SageMaker. Users can also deploy custom algorithms in Docker containers, making it versatile for various machine learning tasks.
+- **Keywords**: machine learning, deep learning, model deployment, Amazon SageMaker, data science, AI, Docker
+- **Popularity**: very popular
+
+## License
+
+Modulift is licensed under the MIT License. See [LICENSE](Licence.md) for more details.
+
+## Contributing
+
+We welcome contributions to Modulift! Please see [CONTRIBUTING.md](CONTRIBUTING.md) for guidelines.
+
+## Contact
+
+For any questions or feedback, please contact the author:
+
+- **Okan Yenigün** - [okanyenigun@gmail.com](mailto:okanyenigun@gmail.com)

modulift-0.0.1.dist-info/RECORD

@@ -0,0 +1,7 @@
+modulift/__init__.py,sha256=CdQMLTINFPRegM1vrC37PMBD9MlHD1PBcSh1lDigJRY,41
+modulift/api.py,sha256=uaXLpJcHddumDWD24uMNtmWYaC-MdxkQMeu0XFPc424,8073
+modulift/data.py,sha256=DOQKk42KXckZSRi9shvTdfiL8m0UzqsTjY-r9PfNLGo,147
+modulift-0.0.1.dist-info/METADATA,sha256=zL3Ynj_X-laQ8IEXbR7hPMv3JxUjVJ2Vg3QoRNQavrI,7952
+modulift-0.0.1.dist-info/WHEEL,sha256=eOLhNAGa2EW3wWl_TU484h7q1UNgy0JXjjoqKoxAAQc,92
+modulift-0.0.1.dist-info/top_level.txt,sha256=BKhbSkUIGpGgZJtDObR81O3ECUVZGwGQkIPdxbihzFc,9
+modulift-0.0.1.dist-info/RECORD,,

modulift-0.0.1.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: bdist_wheel (0.44.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

modulift-0.0.1.dist-info/top_level.txt

@@ -0,0 +1 @@
+modulift