This Github repository is made for the course project of ECE143 (Group 8).
The team members are:

• Yuhao Huang
• Zhiyan Zhu
• Xi Yang
• Yusuf Morsi
• Siddharth Satyam

The presentation slides are available as ECE 143 group 8 submiting version.pdf

The dataset is obtained from a Quarterly Census of Employment and Wages (OCEW) from the past decade (2004-2021).
It can be found here: Quarterly Census of Employment and Wages (OCEW)

The data is structured as:

The Repository has seperate directories for each team member.
Each Directory contains Jupyter Notebook Files along with Python files and readme files to describe how they should be run.
There is also a master Jupyter Notebook in the parent directory which combines work of all team members.
The work is distributed as:

• Yuhao Huang -> Analysis of relationship between employment and wages.
• Zhiyan Zhu -> Analysis of establishments and correlation between establishents, wages and average monthly employment.
• Xi Yang -> Analysis of the ownership’s property
• Yusuf Morsi -> Analysis of average weekly wages & monthly employment, comparision of California vs. counties vs. USA.
• Siddharth Satyam -> Time series Analysis and prediction

(back to top)

Hubot adapter to use with RingCentral Team Messaging.

• How to createa a RingCentral private bot using Hubot
• How to create a RingCentral public bot using Hubot

Create new project with the following structure:

your-bot/
    scripts/
    external-scripts.json

In the root of your bot project, execute:

yarn add hubot@2.19.0 hubot-ringcentral && yarn add --dev babel-polyfill

Take hubot-help for example:

yarn add hubot-help

Then config it to external-scripts.json:

[
    "hubot-help"
]

Let’s assume that we want to add ping feature to the bot.

Create scripts/ping.js file with the following content:

// Commands:
//   hubot ping - ping the bot
module.exports = robot => {
  robot.respond(/ping$/, res => {
    res.send('pong')
  })
}

This step is different for provate bot and public bot.

If you bot is a private bot, you can simply use the default OAuth Redirect URI: https://www.ringcentral.com.
And you can get the token from GUI of https://developer.ringcentral.com.
Create token.json in the root of your bot project with the following content:

{
    "access_token": "the-access-token-string"
}

If you bot is a public bot, You need to set the OAuth Redirect URI to ${RINGCENTRAL_BOT_SERVER}/oauth.

For example, if your bot is running on local with ngrok uri https://xxxxx.ngrok.io, you should set the OAuth Redirect URI to https://xxxxx.ngrok.io/oauth.

When you successfully add the bot to RingCentral Team Messaging, a token.json file will be created for you automatically.

RINGCENTRAL_SERVER=https://platform.devtest.ringcentral.com \
RINGCENTRAL_CLIENT_ID=clientId \
RINGCENTRAL_CLIENT_SECRET=clientSecret \
RINGCENTRAL_BOT_SERVER=https://the-bot-server \
npx hubot -a ringcentral -n x

• RINGCENTRAL_SERVER – This is the RingCentral API server. Optional. By default it’s https://platform.ringcentral.com. Use https://platform.devtest.ringcentral.com for sandbox
• RINGCENTRAL_BOT_SERVER – Optional. The server that your bot is running on. If you use ngork for development, the uri should be https://xxxxx.ngrok.io. It is only required for public bot and when you do not have a RingCentral access token. Ignore this environment variable if your bot is a private bot or if you already have a RingCentral access token.
• -n x means the name of your bot is x. You can use any name

For production login https://app.ringcentral.com, for sandbox login https://app.devtest.ringcentral.com/

Find your bot in RingCentral and talk to it:

Send: x ping
Receive: pong
Send: x help
Receive: xping - ping the bot

Example above assume that your bot’s name is x and you have installed exernal script hubot-help and added custom script ping. For more details about them please read content above.

monkeyplug is a little script to censor profanity in audio files (intended for podcasts, but YMMV) in a few simple steps:

1. The user provides a local audio file (or a URL pointing to an audio file which is downloaded)
2. Either Whisper (GitHub) or the Vosk–API is used to recognize speech in the audio file
3. Each recognized word is checked against a list of profanity or other words you’d like muted
4. ffmpeg is used to create a cleaned audio file, muting or “bleeping” the objectional words

You can then use your favorite media player to play the cleaned audio file.

If provided a video file for input, monkeyplug will attempt to process the audio stream from the file and remultiplex it, copying the original video stream.

monkeyplug is part of a family of projects with similar goals:

• 📼 cleanvid for video files (using SRT-formatted subtitles)
• 🎤 monkeyplug for audio and video files (using either Whisper or the Vosk–API for speech recognition)
• 📕 montag for ebooks

Using pip, to install the latest release from PyPI:

python3 -m pip install -U monkeyplug

Or to install directly from GitHub:

python3 -m pip install -U 'git+https://github.com/mmguero/monkeyplug'

monkeyplug requires:

• FFmpeg
• Python 3
  • mutagen
  • a speech recognition library, either of:
    • Whisper
    • vosk-api with a VOSK compatible model

To install FFmpeg, use your operating system’s package manager or install binaries from ffmpeg.org. The Python dependencies will be installed automatically if you are using pip to install monkeyplug, except for vosk or openai-whisper; as monkeyplug can work with both speech recognition engines, there is not a hard installation requirement for either until runtime.

usage: monkeyplug.py <arguments>

monkeyplug.py

options:
  -v, --verbose [true|false]
                        Verbose/debug output
  -m, --mode <string>   Speech recognition engine (whisper|vosk) (default: whisper)
  -i, --input <string>  Input file (or URL)
  -o, --output <string>
                        Output file
  --output-json <string>
                        Output file to store transcript JSON
  -w, --swears <profanity file>
                        text file containing profanity (default: "swears.txt")
  -a, --audio-params APARAMS
                        Audio parameters for ffmpeg (default depends on output audio codec)
  -c, --channels <int>  Audio output channels (default: 2)
  -s, --sample-rate <int>
                        Audio output sample rate (default: 48000)
  -f, --format <string>
                        Output file format (default: inferred from extension of --output, or "MATCH")
  --pad-milliseconds <int>
                        Milliseconds to pad on either side of muted segments (default: 0)
  --pad-milliseconds-pre <int>
                        Milliseconds to pad before muted segments (default: 0)
  --pad-milliseconds-post <int>
                        Milliseconds to pad after muted segments (default: 0)
  -b, --beep [true|false]
                        Beep instead of silence
  -h, --beep-hertz <int>
                        Beep frequency hertz (default: 1000)
  --beep-mix-normalize [true|false]
                        Normalize mix of audio and beeps (default: False)
  --beep-audio-weight <int>
                        Mix weight for non-beeped audio (default: 1)
  --beep-sine-weight <int>
                        Mix weight for beep (default: 1)
  --beep-dropout-transition <int>
                        Dropout transition for beep (default: 0)
  --force [true|false]  Process file despite existence of embedded tag

VOSK Options:
  --vosk-model-dir <string>
                        VOSK model directory (default: ~/.cache/vosk)
  --vosk-read-frames-chunk <int>
                        WAV frame chunk (default: 8000)

Whisper Options:
  --whisper-model-dir <string>
                        Whisper model directory (~/.cache/whisper)
  --whisper-model-name <string>
                        Whisper model name (base.en)
  --torch-threads <int>
                        Number of threads used by torch for CPU inference (0)

Alternately, a Dockerfile is provided to allow you to run monkeyplug in Docker. You can pull one of the following images:

• VOSK
  • oci.guero.org/monkeyplug:vosk-small
  • oci.guero.org/monkeyplug:vosk-large
• Whisper
  • oci.guero.org/monkeyplug:whisper-tiny.en
  • oci.guero.org/monkeyplug:whisper-tiny
  • oci.guero.org/monkeyplug:whisper-base.en
  • oci.guero.org/monkeyplug:whisper-base
  • oci.guero.org/monkeyplug:whisper-small.en
  • oci.guero.org/monkeyplug:whisper-small
  • oci.guero.org/monkeyplug:whisper-medium.en
  • oci.guero.org/monkeyplug:whisper-medium
  • oci.guero.org/monkeyplug:whisper-large-v1
  • oci.guero.org/monkeyplug:whisper-large-v2
  • oci.guero.org/monkeyplug:whisper-large-v3
  • oci.guero.org/monkeyplug:whisper-large

then run monkeyplug-docker.sh inside the directory where your audio files are located.

If you’d like to help improve monkeyplug, pull requests will be welcomed!

• Seth Grover – Initial work – mmguero

This project is licensed under the BSD 3-Clause License – see the LICENSE file for details.

graphql-api helps you implement a robust GraphQL API in Haskell. By the time a query makes it to your handler you are dealing with strong, static types that make sense for your problem domain. All your handlers are normal Haskell functions because we derive their type signature from the schema. If you have used servant, this will sound familiar.

The library provides type combinators to create a GraphQL schema, and functions to parse and evaluate queries against the schema.

You can find the latest release on hackage.

We implement the GraphQL specification as best as we can in Haskell. We figure they know what they’re doing. Even if an alternative API or behaviour looks nicer, we will defer to the spec.

A simple graphql-api tutorial can be read at readthedocs.io.

To follow along and get your hands dirty, clone this repository, enter the graphql-api root directory, and run:

stack repl tutorial

Say we have a simple GraphQL schema like:

type Hello {
  greeting(who: String!): String!
}

which defines a single top-level type Hello which contains a single field, greeting, that takes a single, required argument who.

We can define this schema in Haskell and implement a simple handler like so:

{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE TypeApplications #-}
{-# LANGUAGE TypeOperators #-}

import Data.Text (Text)
import Data.Monoid ((<>))

import GraphQL
import GraphQL.API
import GraphQL.Resolver (Handler, returns)

type Hello = Object "Hello" '[]
  '[ Argument "who" Text :> Field "greeting" Text ]

hello :: Handler IO Hello
hello = pure (\who -> returns ("Hello " <> who))

run :: Text -> IO Response
run = interpretAnonymousQuery @Hello hello

We require GHC 8.0.2 or later for features like the @Hello type application, and for certain bug fixes. We also support GHC 8.2.

With the code above we can now run a query:

run "{ greeting(who: \"mort\") }"

Which will produce the following GraphQL response:

{
  "data": {
    "greeting": "Hello mort"
  }
}

Our current goal is to gather feedback. We have learned a lot about GraphQL in the course of making this library, but we don’t know what a good GraphQL library looks like in Haskell. Please let us know what you think. We won’t mind if you file a bug telling us how good the library is.

Because we’re still learning, we make no guarantees about API stability, or anything at all really.

We are tracking open problems, missing features & wishlist items in GitHub’s issue tracker.

• Near future:
  • Better error messages (this is really important to us)
  • Full support for recursive data types
  • Close off loose ends in current implementation & gather feedback
• Medium future:
  • Full schema validation
  • Schema introspection
  • Stabilize public API
• Long term:
  • Derive client implementations from types
  • Allow users to implement their own type combinators

• GraphQL Specification (source)
• GraphQL tutorial
• GraphQL AST in Haskell

All files Copyright (c) 2016-2017 Thomas E. Hunger & Jonathan M. Lange, except:

• src/GraphQL/Internal/Syntax/AST.hs
• src/GraphQL/Internal/Syntax/Encoder.hs
• src/GraphQL/Internal/Syntax/Parser.hs

for which see LICENSE.BSD3 in this repository.

raide – A ray of light in the world of IDEs

raide is a simple IDE with a multi project approach in mind. It features currently:

• A save button
• Multiple Tabs of files that are closable and writable. Right click reveals the full path.
• Source highlighting of all languages understood by gtksourceview, including Rust, Java, JSON and Markdown.
• Generatable buttons with commands read from the workspace file raide.ron
• File-based completion, which completes text to previously typed words
• Project-based completion, which completes text of the common programming language It is useful on platforms with limited resources, as the application requires only 90 MB RAM.

• Another feature would be completion at standard library level of the respective language, which completes text to previously typed words.
• File-based search and replace would be another feature

(
    name: "raide",
    exclude_files: [],
    commands: [(name:"build",has_button:true,command:"cargo build",key_binding:None,),(name:"run",has_button:true,command:"./file",key_binding:None,),(name:"format",has_button:true,command:"rustfmt {file}",key_binding:None,),],
)

This config features a

• project level build button
• project level run button
• file level format button

** Sorry, all the api expect the github search is not working. This app is not operable but you can look into the dependencies and latest implementation I will try to make it updated**

Github Compose is you way to track the traending chart on Github.The project is set towards using some of the latest packages and libraraties to consume 4 sperate apis for getting the data.

We are using Ktor Client and SQLDelight for all the heavy lifting with the help of both Koin and Dagger Hilt implemention on separate branches and binging in the freshness of Material3.

Made with ❤️ by Debanshu777

• Jetpack Compose : Jetpack Compose is Android’s modern toolkit for building native UI. It simplifies and accelerates UI development on Android. Quickly bring your app to life with less code, powerful tools, and intuitive Kotlin APIs.
• Material3 : The Material 3 Design Kit is built to work with the Material Theme Builder Figma plugin. Select an image or color to visualize dynamic color in your UI.
• Ktor Clinet : Ktor includes a multiplatform asynchronous HTTP client, which allows you to make requests and handle responses, extend its functionality with plugins, such as authentication, JSON serialization, and so on. In this tutorial, we’ll create a simple client application for sending a request and receiving a response.
• SQLDelight : SQLDelight generates typesafe kotlin APIs from your SQL statements. It verifies your schema, statements, and migrations at compile-time and provides IDE features like autocomplete and refactoring which make writing and maintaining SQL simple.
• Koin : Koin is a pragmatic and lightweight dependency injection framework for Kotlin developers.
• Coroutines : A coroutine is a concurrency design pattern that you can use on Android to simplify code that executes asynchronously. Coroutines were added to Kotlin in version 1.3 and are based on established concepts from other languages.
• Flow : Flow is the Kotlin type that can be used to model streams of data. Just like LiveData and RxJava streams, Flow lets you implement the observer pattern: a software design pattern that consists of an object (a.k.a. observable, producer, source, emitter) that maintains a list of its dependents, called observers (subscribers, collectors, receivers, etc.), and notifies them automatically of any state changes.
• Daggar Hilt : Hilt is a dependency injection library for Android that reduces the boilerplate of doing manual dependency injection in your project. Doing manual dependency injection requires you to construct every class and its dependencies by hand, and to use containers to reuse and manage dependencies.
• Kotlin serialization : Kotlin serialization consists of a compiler plugin, that generates visitor code for serializable classes, runtime library with core serialization API and support libraries with various serialization formats.
• Navigating with Compose : The Navigation component provides support for Jetpack Compose applications. You can navigate between composables while taking advantage of the Navigation component’s infrastructure and features.
• Lottie : Lottie is a library for Android, iOS, Web, and Windows that parses Adobe After Effects animations exported as json with Bodymovin and renders them natively on mobile and on the web!
• Coil : An image loading library for Android backed by Kotlin Coroutines.
• Accompanist : Accompanist is a group of libraries that aim to supplement Jetpack Compose with features that are commonly required by developers but not yet available.

You don’t have to do much setup for the project, just nedd to get the API key for github-trending from Rapid API it is free. Get the RapidAPIHost and RapidAPIKey then set it inside local.properties

RapidAPIHost=github-trending.p.rapidapi.com
RapidAPIKey=xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

For other usecases we are using public apis

Awesome! If you want to contribute to this project, you’re always welcome! Have any questions, doubts or want to present your opinions, views? You’re always welcome. You can mail me at debanshudatta123@gmail.com or make an issue. Looking for contributors! Don’t be shy. 😁 Feel free to open issues/pull requests to help me improve this project.

• When reporting a new Issue, make sure to attach Screenshots, Videos or GIFs of the problem you are reporting.
• When submitting a new PR, make sure tests are all green. Write new tests if necessary.

MIT License

Copyright (c) 2022 Debanshu Datta

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.

HomeInflux collects data from a set of plugins and stores it in influxdb. There are already many really good projects out there that work in the same way, but this one is designed to be simple to use and has a set of plugins that could be helpful for home use.

Grafana displaying the collected data

• Afterburner plugin: Collects CPU/GPU temps and many other statistics from MSI Afterburner Remote Server
• Hue Sensor plugin: reads the available data from your Hue sensors (temp, light, presence)
• Fritz.Box plugin: reads the upstream and downstream history from your Fritz Box (TR064)
• SNMP plugin: reads the desired SNMP OIDs
• Ping Plugin: ping a set of hosts

1. Build the project using maven. The jar will be located in the ./target directory and the required libraries in ./target/lib

mvn install

2. Run it a first time (config file location optional). On the first run it will generate a sample config file and exit

java -jar HomeInflux-1.0.jar [/path/to/config/file.json]

3. Edit the sample config file and enable/configure the plugins
4. Run it again

If you enable the plugin, you have to specify the IP adress of the hue bridge. You do not have yet the required access key, that is fine and normal. if now you run HomeInflux it will prompt you to press the Hue bridge button and it will print the required key on the console. You will then have to copy paste this key in your config file.

Bootjack is a porting of Twitter Bootstrap 3.0.x in Dart.

• API Reference
• Git Repository
• Discussion
• Issues

Include the following in your pubspec.yaml:

dependencies:
  bootjack: any

Then run the Pub Package Manager in Dart Editor (Tool > Pub Install). If you are using a different editor, run the command
(comes with the Dart SDK):

pub install

First of all in your HTML file, you need to include the CSS resource:

<head>
	...
	<link rel="stylesheet" href="https://github.com/rikulo/packages/bootjack/css/bootstrap.min.css">
</head>

Most of the functions in Bootjack components are automatic — you only need to give the right CSS class on DOM elements and call a global function to register.

For example, a Dropdown button component is prepared by giving the following HTML snippet:

<button class="btn btn-default dropdown-toggle" data-toggle="dropdown">
	Button
	<span class="caret"></span>
</button>
<ul class="dropdown-menu">
	<li><a href="#">Menu Item #1</a></li>
	<li><a href="#">Menu Item #2</a></li>
	<li><a href="#">Menu Item #3</a></li>
</ul>

With the following global registration in Dart:

void main() {
	Dropdown.use();
}

That’s right. All you need to do in Dart is to tell Bootjack you are using Dropdown components. You can also progammatically access and manipulate the Dropdown:

Dropdown dd = Dropdown.wire(element);
dd.toggle();

Check more examples and the API reference for more features. Also, you can read the reference of Bootstrap.

You are welcome to submit bugs and feature requests. Or even better if you can fix or implement them!

If you’d like to contribute back to the core, you can fork this repository and send us a pull request, when it is ready.

Please be aware that one of Rikulo’s design goals is to keep the sphere of API as neat and consistency as possible. Strong enhancement always demands greater consensus.

If you are new to Git or GitHub, please read this guide first.

• Quire – a simple, collaborative, multi-level task management tool.
• Keikai – a sophisticated spreadsheet for big data

Bundler is now maintained in the rubygems/rubygems repository.

Bundler makes sure Ruby applications run the same code on every machine.

It does this by managing the gems that the application depends on. Given a list of gems, it can automatically download and install those gems, as well as any other gems needed by the gems that are listed. Before installing gems, it checks the versions of every gem to make sure that they are compatible, and can all be loaded at the same time. After the gems have been installed, Bundler can help you update some or all of them when new versions become available. Finally, it records the exact versions that have been installed, so that others can install the exact same gems.

To install (or update to the latest version):

gem install bundler

To install a prerelease version (if one is available), run gem install bundler --pre. To uninstall Bundler, run gem uninstall bundler.

Bundler is most commonly used to manage your application’s dependencies. For example, these commands will allow you to use Bundler to manage the rspec gem for your application:

bundle init
bundle add rspec
bundle install
bundle exec rspec

See bundler.io for the full documentation.

For help with common problems, see TROUBLESHOOTING.

Still stuck? Try filing an issue.

To see what has changed in recent versions of Bundler, see the CHANGELOG.

To get in touch with the Bundler core team and other Bundler users, please see getting help.

If you’d like to contribute to Bundler, that’s awesome, and we <3 you. We’ve put together the Bundler contributor guide with all of the information you need to get started.

If you’d like to request a substantial change to Bundler or to the Bundler documentation, refer to the Bundler RFC process for more information.

While some Bundler contributors are compensated by Ruby Together, the project maintainers make decisions independent of Ruby Together. As a project, we welcome contributions regardless of the author’s affiliation with Ruby Together.

Ruby Together pays some Bundler maintainers for their ongoing work. As a grassroots initiative committed to supporting the critical Ruby infrastructure you rely on, Ruby Together is funded entirely by the Ruby community. Contribute today as an individual or (better yet) as a company to ensure that Bundler, RubyGems, and other shared tooling is around for years to come.

Everyone interacting in the Bundler project’s codebases, issue trackers, chat rooms, and mailing lists is expected to follow the Bundler code of conduct.

Bundler is available under an MIT License.