This is necessary so I can start using this module in the hamburglar project without having to request it in some weird way.

There is a getFollowers() function already in giggity. I would like to add the ability to include followers, then followers of followers, and so on to a depth of x. This would be added as a separate nested dictionary added as a key to the user level called followers.

In this way we should be able to find mutual followers to a certain organization or user.

I personally recommend Apache 2.0, but you need to have one.

Write json file to database. I think it would be best if this was stored in an actual file, so sqlite seems like the way to go, although I would be fine with a mysql database too.

This would mean there would need to be a setup script for making the database.

It currently reads

"Copyright [yyyy] [name of copyright owner]"

Unless your name is "[name of copyright owner]", you should probably change this.

many of the keys are just links to other endpoints. Not much of this is useful, so it would make things cleaner to just not include them. Here is an example of what might get deleted:

This is edited from the results given from a request to the repo endpoint of the api

Repo Structure (This is a fairly liberal list, I think it could probably be cut down more)

{
    "id": 59394602,
    "name": "AaronConversation",
    "full_name": "needmorecowbell/AaronConversation",
    "private": false,
    "owner": {
      "login": "needmorecowbell"
    },
    "html_url": "https://github.com/needmorecowbell/AaronConversation",
    "description": "Old code from a fun postal service experience",
    "fork": false,
    "url": "https://api.github.com/repos/needmorecowbell/AaronConversation",
    "forks_url": "https://api.github.com/repos/needmorecowbell/AaronConversation/forks",
    "created_at": "2016-05-22T04:20:41Z",
    "updated_at": "2016-05-22T04:21:56Z",
    "pushed_at": "2016-05-22T04:21:55Z",
    "size": 9,
    "stargazers_count": 0,
    "watchers_count": 0,
    "language": "Java",
    "has_issues": true,
    "has_projects": true,
    "has_downloads": true,
    "has_wiki": true,
    "has_pages": false,
    "forks_count": 0,
    "open_issues_count": 0,
    "license": null,
    "forks": 0,
    "open_issues": 0,
    "watchers": 0,
    "default_branch": "master"
 }

Testing makes sure that what you think your code does is actually what it does. It also helps to document your code.

Kenneth Reitz (i.e. the guy behind requests, which you use in this project) wrote an article on testing & Python, which I recommend.

Glenn Quagmire--giggity

[root@vm giggity]# python3.5 giggity.py -O username.json -v -u username   


   __ _(_) __ _  __ _(_) |_ _   _ 
  / _` | |/ _` |/ _` | | __| | | |
 | (_| | | (_| | (_| | | |_| |_| |
  \__, |_|\__, |\__, |_|\__|\__, |
  |___/   |___/ |___/       |___/ 


Traceback (most recent call last):
  File "giggity.py", line 272, in <module>
    g = giggity()
  File "giggity.py", line 10, in __init__
    self.depth = depth
NameError: name 'depth' is not defined

Depth isn't in the argument's list.

class giggity():

    def __init__(self, auth_usr="", auth_pss=""):
        self.depth = depth

if (args.depth):
    g = giggity(user, psswd, int(args.depth))
else:
    g = giggity(user, psswd)

Seems it was added here but not updated in the arglist 9a9bf0f

Kenneth Reitz gain provides a good example: https://github.com/kennethreitz/setup.py

You could also go with Poetry instead, as a way to track your dependencies if you wanted to try the hip new thing.

Github limits you to 5000 requests per hour when authenticated and 60 when unauthenticated. Giggity should be able to check for the different error messages and handle them appropriately. This is now an important issue because of how many queries are being made.

For example:

Abuse and limited responses will look like this, and should be handled by telling the script to ping every 15 minutes to see if it can start scraping again.

HTTP/1.1 403 Forbidden
Content-Type: application/json; charset=utf-8
Connection: close
{
  "message": "You have triggered an abuse detection mechanism and have been temporarily blocked from content creation. Please retry your request again later.",
  "documentation_url": "https://developer.github.com/v3/#abuse-rate-limits"
}

HTTP/1.1 403 Forbidden
Date: Tue, 20 Aug 2013 14:50:41 GMT
Status: 403 Forbidden
X-RateLimit-Limit: 60
X-RateLimit-Remaining: 0
X-RateLimit-Reset: 1377013266
{
   "message": "API rate limit exceeded for xxx.xxx.xxx.xxx. (But here's the good news: Authenticated requests get a higher rate limit. Check out the documentation for more details.)",
   "documentation_url": "https://developer.github.com/v3/#rate-limiting"
}

Needs more attention than just a readme at this point. A wiki would be a good addition to clearly detail the project's features.

for example...

• get members of organization (ie the code in the readme just put into a method in giggity)
• get list of followers to user or organization

Here is a solution to the issue: https://stackoverflow.com/questions/30656761/github-search-api-only-return-30-results

The request needs to be made and page incremented until there are no more results left.

I want to be able to generate a graphic of the pulled organization. Think maltego, something with the org as the head node, branching down. Should be fairly obvious for org and and org's members, but it would be interesting to see interconnected relationships like mutual followers of the same individual or repo. Because of how many results might exist, I think color coded dots with popups showing the details of the node would be a good way of handling it.

Something that looks a little like this --

In your README.md, I'm expecting to see both example input as well as example output.

In essence, you want to make sure that your target audience has no doubts about how they would integrate into their workflow.