abstract-github 0.0.0.1__tar.gz

abstract_github-0.0.0.1/LICENSE

@@ -0,0 +1,46 @@
+This project is licensed under the MIT License
+
+MIT License
+
+The MIT License was first developed at the Massachusetts Institute of Technology (MIT) in the late 1980s. The exact origins MIT license are bit of mystery. Like the Apache 2.0, and BSD family of licenses the MIT License is a permissive software license that places few restrictions of reuse. Users of software using an MIT License are permitted to use, copy, modify, merge publish, distribute, sublicense and sell copies of the software. Some notable projects use the MIT License including Ruby on Rails, and the X Windows System.
+MIT License Conditions
+The MIT License is relatively simple and short. Below is the text of the MIT License from the Open Software Initiative.
+Begin license text.
+
+Copyright <YEAR> <COPYRIGHT HOLDER>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 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.
+End license text.
+Using MIT Licensed Code
+
+ 
+
+The basic conditions of using the MIT License are:
+
+1. The original copyright notice
+
+2. A copy of the license itself
+
+are including in all copies or any substantial portions of the software.
+MIT License Compatibility
+
+The MIT License is highly compatible with other permissive licenses. Including the BSD family of licenses. It is generally compatible with  GNU GPL group of licenses. However if you distribute the code that contains or is derivative of GNU GPL code the final project must of GPL compliant. In other words any source code must of publicly available. 
+MIT License, Patents
+
+The MIT License was developed before patenting software was a common practice in the U.S. It therefore does not contain an express patent license. The broad nature of the license in general, is considered by some to encompass an implicit waiver of patent rights. If you are concerned about patent rights, the Apache 2.0 license contains an explicit contributor's patent license.
+MIT No Attribution License (MIT-0)
+
+The MIT No Attribution License is a Public Domain equivalent license it is similar to the  BSD Free license. 
+
+ 
+
+Copyright <YEAR><COPYRIGHT HOLDER>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 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.
+

abstract_github-0.0.0.1/PKG-INFO

@@ -0,0 +1,18 @@
+Metadata-Version: 2.1
+Name: abstract_github
+Version: 0.0.0.1
+Summary: abstract_github is a Python module that serves aggregates github data
+Home-page: https://github.com/AbstractEndeavors/abstract_ai
+Author: putkoff
+Author-email: partners@abstractendeavors.com
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Requires-Python: >=3.6
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: abstract_utilities
+
+#magnets who invented them; how do they work?

abstract_github-0.0.0.1/README.md

@@ -0,0 +1 @@
+#magnets who invented them; how do they work?

abstract_github-0.0.0.1/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

abstract_github-0.0.0.1/setup.py

@@ -0,0 +1,27 @@
+from time import time
+import setuptools
+with open("README.md", "r", encoding="utf-8") as fh:
+    long_description = fh.read()
+setuptools.setup(
+    name='abstract_github',
+    version='0.0.0.1',
+    author='putkoff',
+    author_email='partners@abstractendeavors.com',
+    description="abstract_github is a Python module that serves aggregates github data",
+    long_description=long_description,
+    long_description_content_type='text/markdown',
+    url='https://github.com/AbstractEndeavors/abstract_ai',
+    classifiers=[
+          'Development Status :: 3 - Alpha',
+          'Intended Audience :: Developers',
+          'License :: OSI Approved :: MIT License',
+          'Programming Language :: Python :: 3',
+          'Programming Language :: Python :: 3.11',
+      ],
+    install_requires=['abstract_utilities'],
+    package_dir={"": "src"},
+    packages=setuptools.find_packages(where="src"),
+    python_requires=">=3.6",
+    # Add this line to include wheel format in your distribution
+    setup_requires=['wheel'],
+)

abstract_github-0.0.0.1/src/abstract_github/__init__.py

@@ -0,0 +1,4 @@
+from .call_manager import *
+from .rate_limiter import *
+from .safe_call_data import *
+from .utils import *

abstract_github-0.0.0.1/src/abstract_github/call_manager.py

@@ -0,0 +1,34 @@
+from .safe_call_data import get_limited_call_safe,os,safe_dump_to_file,safe_read_from_json
+from .utils import get_user_name_from_github_link
+class completeCallsManager:
+    def __init__(self):
+    
+        self.completed_list_path = os.path.join(os.getcwd(),'completed_list.json')
+        self.completed_list = self.load_completed_list()
+    def load_completed_list(self):
+        if not os.path.isfile(self.completed_list_path):
+            safe_dump_to_file(data={},file_path= self.completed_list_path)
+        self.completed_list = safe_read_from_json( self.completed_list_path)
+        return self.completed_list
+    async def call_data_check(self,username,data_type):
+        # Initialize user data if not already in completed_list
+        data={}
+        if self.completed_list.get(username) is None:
+            self.completed_list[username] = {"user_info": None, "repo_info": None}
+        # Check if data for this key exists in the completed_list_path
+        if self.completed_list.get(str(username), {}).get(str(data_type)) is None:
+            url = f"https://api.github.com/users/{username}"
+
+            # Modify the URL if we are fetching repo info
+            if data_type == 'repo_info':
+                url = f"{url}/repos"
+            
+            # Fetch the data asynchronously (assuming this is an asynchronous function)
+            data = await get_limited_call_safe(url)
+            if data and isinstance(data,dict):
+                self.completed_list[username][data_type] = True
+            # Save the data in the completed_list
+            # Persist the updated completed_list to the JSON file
+            safe_dump_to_file(data=self.completed_list, file_path=self.completed_list_path)
+
+        return data

abstract_github-0.0.0.1/src/abstract_github/rate_limiter.py

@@ -0,0 +1,69 @@
+import time
+import requests
+from requests.exceptions import HTTPError
+
+# GitHub API rate limits
+RATE_LIMIT_URL = "https://api.github.com/rate_limit"
+
+def rate_limited_api_call(url, method='GET', headers=None, data=None, max_retries=5):
+    """
+    Make a rate-limited GitHub API call with retries and backoff on failure.
+    
+    Args:
+    - url (str): API endpoint URL.
+    - method (str): HTTP method ('GET', 'POST', 'PATCH', etc.).
+    - headers (dict): Optional HTTP headers.
+    - data (dict): Optional payload for POST/PATCH requests.
+    - max_retries (int): Maximum number of retries on failure.
+    
+    Returns:
+    - Response object (requests.Response) if successful, None otherwise.
+    """
+    retries = 0
+    while retries <= max_retries:
+        try:
+            # Make the API request
+            response = requests.request(method, url, headers=headers, json=data)
+            
+            # Check for HTTP errors
+            response.raise_for_status()
+            
+            # Check if we are rate-limited
+            remaining = int(response.headers.get('X-RateLimit-Remaining', 1))
+            reset_time = int(response.headers.get('X-RateLimit-Reset', time.time() + 60))
+            
+            if remaining == 0:
+                # Calculate the wait time until the rate limit resets
+                sleep_time = max(0, reset_time - time.time())
+                print(f"Rate limit exceeded. Waiting for {sleep_time} seconds...")
+                time.sleep(sleep_time)
+                continue  # Retry after waiting
+            
+            return response  # If request was successful
+
+        except HTTPError as http_err:
+            # Handle rate limit error (403 status)
+            if response.status_code == 403 and 'X-RateLimit-Remaining' in response.headers:
+                reset_time = int(response.headers['X-RateLimit-Reset'])
+                sleep_time = max(0, reset_time - time.time())
+                print(f"Rate limit hit, retrying in {sleep_time} seconds...")
+                time.sleep(sleep_time)
+                retries += 1
+            else:
+                print(f"HTTP error occurred: {http_err}")
+                return None
+        
+        except Exception as err:
+            print(f"Other error occurred: {err}")
+            return None
+        
+        # Exponential backoff for retries
+        retries += 1
+        backoff_time = 2 ** retries
+        print(f"Retrying in {backoff_time} seconds...")
+        time.sleep(backoff_time)
+    
+    print("Max retries exceeded.")
+    return None
+
+

abstract_github-0.0.0.1/src/abstract_github/safe_call_data.py

@@ -0,0 +1,76 @@
+from .utils import *
+from .rate_limiter import rate_limited_api_call
+async def fetch_data_from_api(url):
+    """
+    Simulate an async function that fetches data from an API.
+    Replace this with your actual API call logic.
+    """
+    await asyncio.sleep(1)  # Simulate network delay
+    return {"dummy_data": f"Data from {url}"}
+
+
+async def get_limited_call_safe(call_url,token=None):
+    """
+    This function safely calls the API and logs both successful responses and errors.
+    """
+    response_data = {}
+    
+    print(call_url)
+    # Attempt to make the API call
+    user_info =  rate_limited_api_call(call_url)
+
+    if user_info:
+        # Successful response, parse JSON
+        response_data = user_info
+        if response_data:
+            try:
+                response_data = response_data.json()
+            except:
+                response_data = response_data.text
+        response_data = process_templated_urls(response_data)
+        # Log the successful response
+        log_response(call_url, response_data)
+    try:
+        print('hihihi')
+    except Exception as e:
+        # If any error occurs, log it and add error details to the response
+        response_data = {
+            "response": None,
+            "error": True,
+            "error_message": str(e)
+        }
+        log_error(call_url, e)
+
+    return response_data
+
+def process_templated_urls(obj):
+    """
+    Recursively processes nested dictionaries and lists to replace template parts in URLs.
+    """
+    if isinstance(obj, dict):
+        # Process dictionary by iterating through key-value pairs
+        for key, value in obj.items():
+            if isinstance(value, str):
+                # If a string contains a URL template, remove or replace it
+                if '{' in value:
+                    obj[key] = value.replace('{/sha}', '').replace('{/other_user}', '').replace('{/gist_id}', '')
+            else:
+                # If value is a nested dictionary or list, process it recursively
+                obj[key] = process_templated_urls(value)
+    elif isinstance(obj, list):
+        # If the object is a list, process each element recursively
+        for i, item in enumerate(obj):
+            obj[i] = process_templated_urls(item)
+    
+    return obj
+def log_response(call_url, response):
+    """
+    Logs the API response.
+    """
+    logging.info(f"API Call to {call_url} succeeded. Response: {json.dumps(response)}")
+
+def log_error(call_url, error):
+    """
+    Logs any error that occurred during the API call.
+    """
+    logging.error(f"API Call to {call_url} failed. Error: {str(error)}")

abstract_github-0.0.0.1/src/abstract_github/utils.py

@@ -0,0 +1,10 @@
+import requests,asyncio,json,os
+from abstract_utilities import *
+base_url = "https://api.github.com/users/"
+
+def get_github_from_user_name(username):
+    return f'https://github.com/{username}'
+def get_user_name_from_github_link(github_link):
+    return make_list([subdir for subdir in github_link.split('github.com')[-1].split('/') if subdir] or None)[0]
+def get_clean_string(string):
+    return eatAll(string,['/','\n',' ','\t']).split('/')[-1]

abstract_github-0.0.0.1/src/abstract_github.egg-info/PKG-INFO

@@ -0,0 +1,18 @@
+Metadata-Version: 2.1
+Name: abstract_github
+Version: 0.0.0.1
+Summary: abstract_github is a Python module that serves aggregates github data
+Home-page: https://github.com/AbstractEndeavors/abstract_ai
+Author: putkoff
+Author-email: partners@abstractendeavors.com
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Requires-Python: >=3.6
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: abstract_utilities
+
+#magnets who invented them; how do they work?

abstract_github-0.0.0.1/src/abstract_github.egg-info/SOURCES.txt

@@ -0,0 +1,13 @@
+LICENSE
+README.md
+setup.py
+src/abstract_github/__init__.py
+src/abstract_github/call_manager.py
+src/abstract_github/rate_limiter.py
+src/abstract_github/safe_call_data.py
+src/abstract_github/utils.py
+src/abstract_github.egg-info/PKG-INFO
+src/abstract_github.egg-info/SOURCES.txt
+src/abstract_github.egg-info/dependency_links.txt
+src/abstract_github.egg-info/requires.txt
+src/abstract_github.egg-info/top_level.txt

abstract_github-0.0.0.1/src/abstract_github.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

abstract_github-0.0.0.1/src/abstract_github.egg-info/requires.txt

@@ -0,0 +1 @@
+abstract_utilities

abstract_github-0.0.0.1/src/abstract_github.egg-info/top_level.txt

@@ -0,0 +1 @@
+abstract_github