Utlyz is an application that works on the command line and makes life easier for you. If you want to check the score of all ongoing matches in cricket or want to check if you got any new friend requests or notifications on FB, Utlyz is the right application for you! Follow the steps on INSTALL.md to install this and run it on your laptop or dekstp.

Currently, Utlyz supports 8 things:

1. Facebook Access
2. Checking cricket scores and schedules (from Cricbuzz)
3. Getting lyrics of songs
4. Searching on google and wikipedia
5. Checking news bulletins (from reuters)
6. Checking football scores (from Goal.com)
7. Allows you to have access to random XKCD images in a separate XKCD directory.
8. Doing basic calculations.

• FacebookCLI

  

  Let’s you to access your FB account from the command line and returns various things number of unread notifications, messages or friend requests you have.

• Cricket Updates

  

  Let’s you to check score updates and cricket schedules of the current month from your command line itself.

• Lyrics

  

  Let’s you get the lyrics of whatever song you want. All you need to do is, enter the name of the song after typing in the comannd, and 💥BOOM!💥 You have your song’s lyrics in front of you on the command line.

• Searching

  Let’s you to access google and wikipedia from the command line itself! All you need to do is type the –google or –wiki options to do a google search or a wiki search. After typing the commands, you’ll be prompted to enter the topic you want to search about. If you do a Google search, it’ll display the most popular links related to that particular topic. Just clicking on the link will redirect you to the browser.

  Note : In case of a wiki search, the entire wikipedia data is displayed on the command line apart from tables and images.

• News

  

  Let’s you get the access to the latest news bulletins from reuters directly on your command line.

• Football

  

  Let’s you get scores of the ongoing matches and matches that just got over on that particular day.

• XKCD

  

  Downloads random XKCD images for you to read in the directory XKCD inside the Utlities folder in your local repository(Laptop or Desktop).

• Calculator

  

  Let’s you add, subtract, multiply, divide or find the modulus of two numbers.

The functionalities it currently supports are:

1) Facebook updates
--fr			Gives the number of new friend requests you have
--msg			Gives the number of unread messages you have
--notifs		Gives the number of unseen notifications you have
--bdays			Gives the list of all those people who have their birthday on that particular day

2) Cricket updates
--score			Gives the scores of all ongoing and recently finished matches
--schedule		Gives the schedule of all international matches throughout the ongoing month

3) Lyrics
--lyr			Gives the lyrics of the song you enter after executing the command

4) Searching
--google		Gives the links of the most popular sites visited w.r.t a particular topic
--wiki			Gives the whole wikipedia information regarding a topic on the Command Line itself

5) News
--trending		Gives you trending news topics

6) Football
--scores		Gives you the scores of the matches

7) XKCD
--image			Allows you to download XKCD images

8) Calculator
--add			Allows you to add two numbers
--sub			Allows you to subtract two numbers
--mul			Allows you to multiply two numbers
--div			Allows you to divide two numbers
--mod			Allows you to find modulus of two numbers

It’s a project in it’s budding stage currently and you’re most welcome to create issues and PR’s. Your comments would be valuable! Please fork and clone the repository and run it in your virtual environment.

Note : Utylz works best with Ubuntu

https://www.file-tree-generator.miglisoft.com/

• Overview
• Quick start
• Options
• How to customize the HTML/ CSS
• Connnectors
• Contribute
• Versionning
• Authors
• License

File Tree Browser is a Javascript plugin built to browse folders and select files.

It retrieves directories and files recursively with Ajax from a main directory and displays the tree structure. You can browse and select, move files from folder to folder, do any stuff with the choosen file.

File Tree Browser is programmed in Vanilla Javascript (compiled TypeScript) and doesn’t require any dependency.

a PHP connector is provided to retrieve the main directory content, you can write your own in any server language (NodeJS, ASP, …).

The default template is built with Bootstrap 4, but Bootstrap is not required at all. You can easily add your own HTML/CSS template and change markup to fit your needs.

Clone / download or install with npm

  npm install @migliori/file-tree-browser@1.1.1

• Upload the dist folder on your server
• add the HTML markup on your page:

<script src="dist/js/file-tree-browser.js"></script>
<script>
    document.addEventListener("DOMContentLoaded", function(event) {

        var options = {
            mainDir: '/path/to/directory',
            elementClick: function (filePath, fileName) {
                // do anything you want
            },
            cancelBtnClick: function (filePath, fileName) {
                // do anything you want
            },
            okBtnClick: function (filePath, fileName) {
                // do anything you want
            }
        };

        var ft = new FileTreeBrowser('file-tree-browser-wrapper', options);
    });
</script>

The template files are used to generate the File Explorer html code.

They are located in dist/templates/

• Create your HTML file + your css file with the same name for both in dist/templates/

• Your HTML template MUST:

  • include exactly the same <template> tags with the exact IDs as the default Bootstrap 4 template. ie:

    <template id="explorer-mode">...</template>

  • Each <template> tag MUST include elements having the prefixed CSS classes ft-

• Load your template using the template option:

  <script>
      document.addEventListener("DOMContentLoaded", function(event) {
  
          var options = {
              // ...
              template: 'your-custom-template'
          };
  
          var ft = new FileTreeBrowser('file-tree-browser-wrapper', options);
      });
  </script>

You can use any HTML structure, any element, as long as the templates are all present with their respective IDs, and all the necessary prefixed classes are present in each of them.

WARNING: if there’s a missing <template> tag or a missing prefixed class, Javascript will throw the following console error:

'Augh, there was an error!'

The default connector is written in PHP. You can write your own in any server language (nodeJs, ASP, …). ie:

• create your connector file named dist/connectors.connector.asp

• Load it using the connector option:

  <script>
      document.addEventListener("DOMContentLoaded", function(event) {
  
          var options = {
              // ...
              connector: 'asp'
          };
  
          var ft = new FileTreeBrowser('file-tree-browser-wrapper', options);
      });
  </script>

Any new connector or cool template is welcome!

We use SemVer for versioning. For the versions available, see the tags on this repository.

• Gilles Migliori – Initial work – Migliori

This project is licensed under the GNU GENERAL PUBLIC LICENSE – see the LICENSE file for details

Digitization of documents with Tika on Databricks : The volume of available data is growing by the second. About 64 zettabytes was created or copied last year, according to IDC, a technology market research firm. By 2025, this number will grow to an estimated 175 zetabytes, and it is becoming increasingly granular and difficult to codify, unify, and centralize. And though more financial services institutions (FSIs) are talking about big data and using technology to capture more data than ever, Forrester reports that 70% of all data within an enterprise still goes unused for analytics. The open source nature of Lakehouse for Financial Services makes it possible for bank compliance officers, insurance underwriting agents or claim adjusters to combine latest technologies in optical character recognition (OCR) and natural language processing (NLP) in order to transform any financial document, in any format, into valuable data assets. The Apache Tika toolkit detects and extracts metadata and text from over a thousand different file types (such as PPT, XLS, and PDF). Combined with Tesseract, the most commonly used OCR technology, there is literally no limit to what files we can ingest, store and exploit for analytics / operation purpose. In this solution, we will use our newly released spark input format tika-ocr to extract text from PDF reports available online

• antoine.amend@databricks.com
• eon.retief@databricks.com

© 2022 Databricks, Inc. All rights reserved. The source in this notebook is provided subject to the Databricks License [https://databricks.com/db-license-source]. All included or referenced third party libraries are subject to the licenses set forth below.

“Elicitation: the act of drawing or bringing out or forth; educing; evoking.” – The Dictionary

Elicitation is a work-in-progress modification for the game Minecraft which is focused on magic. It is being developed purely for the fun of it and work on it may be dropped at any time.

If you’d like to help with development, please clone this repository and then follow the guidelines given here (Initial Setup) to set up the workspace. You may then begin working in your own branch, and when you are ready to merge your changes, you can submit a pull request.

If you want to install the latest version of the mod, you can compile it from source by following the steps for Development given above to set up your workspace. You may then navigate to the project directory and run the command ./gradlew build (Linux), ./gradlew.bat build (Windows), or bash gradlew build (Mac OS X). The compiled .jar file will be placed inside of project-directory/build/libs.

For more information on development/compilation, please visit the Getting Started with ForgeGradle guide.

You can also check out the official Elicitation Discord server here: https://discord.gg/t3SnPqZ

This extension provides support for Eloquent relation role (table inheritance) composition.

For license information check the LICENSE-file.

The preferred way to install this extension is through composer.

Either run

php composer.phar require --prefer-dist illuminatech/db-role

or add

"illuminatech/db-role": "*"

to the require section of your composer.json.

This extension provides support for Eloquent relation role composition, which is also known as table inheritance.

For example: assume we have a database for the University. There are students studying in the University, and there are instructors teaching the students. Student has a study group and scholarship information, while instructor has a rank and salary. However, both student and instructor have name, address, phone number and so on. Thus we can split their data in the three different tables:

• ‘humans’ – stores common data
• ‘students’ – stores student special data and reference to the ‘humans’ record
• ‘instructors’ – stores instructor special data and reference to the ‘humans’ record

DDL for such solution may look like following:

CREATE TABLE `humans`
(
   `id` integer NOT NULL AUTO_INCREMENT,
   `role` varchar(20) NOT NULL,
   `name` varchar(64) NOT NULL,
   `address` varchar(64) NOT NULL,
   `phone` varchar(20) NOT NULL,
    PRIMARY KEY (`id`)
) ENGINE InnoDB;

CREATE TABLE `students`
(
   `human_id` integer NOT NULL,
   `study_group_id` integer NOT NULL,
   `has_scholarship` integer(1) NOT NULL,
    PRIMARY KEY (`human_id`)
    FOREIGN KEY (`human_id`) REFERENCES `humans` (`id`) ON DELETE CASCADE ON UPDATE CASCADE,
) ENGINE InnoDB;

CREATE TABLE `instructors`
(
   `human_id` integer NOT NULL,
   `rank_id` integer NOT NULL,
   `salary` integer NOT NULL,
    PRIMARY KEY (`human_id`)
    FOREIGN KEY (`human_id`) REFERENCES `humans` (`id`) ON DELETE CASCADE ON UPDATE CASCADE,
) ENGINE InnoDB;

This extension introduces \Illuminatech\DbRole\InheritRole trait, which allows role relation based Eloquent inheritance. In order to make it work, first of all, you should create an Eloquent class for the base table, in our example it will be ‘humans’:

<?php

use Illuminate\Database\Eloquent\Model;

class Human extends Model
{
    /**
     * {@inheritdoc}
     */
    protected $table = 'humans';
    
    // ...
}

Then you will be able to compose Eloquent classes, which implements role-based inheritance using \Illuminatech\DbRole\InheritRole. There are 2 different ways for such classes composition:

• Master role inheritance
• Slave role inheritance

This approach assumes role Eloquent class to be a descendant of the base role class, using ‘has-one’ relation to the slave one.

<?php

use Illuminate\Database\Eloquent\Relations\HasOne;
use Illuminatech\DbRole\InheritRole;

class Student extends Human // extending `Human` - not `Model`!
{
    use InheritRole;

    /**
     * Defines name of the relation to the slave table
     * 
     * @return string
     */
    protected function roleRelationName(): string
    {
        return 'studentRole';
    }

    /**
     * Defines attribute values, which should be automatically saved to 'humans' table
     * 
     * @return array
     */
    protected function roleMarkingAttributes(): array
    {
        return [
            'role_id' => 'student', // mark 'Human' record as 'student'
        ];
    }
    
    public function studentRole(): HasOne
    {
        // Here `StudentRole` is an Eloquent, which uses 'students' table :
        return $this->hasOne(StudentRole::class, 'human_id');
    }
}

The main benefit of this approach is that role class directly inherits all methods and logic from the base one. However, you’ll need to declare an extra Eloquent class, which corresponds the role table. In order separate ‘Student’ records from ‘Instructor’ ones during the search process, a default scope named ‘inherit-role’ automatically defined, adding roleMarkingAttributes() to the query ‘where’ condition.

This approach should be chosen in case most functionality depends on the ‘Human’ attributes.

This approach assumes a role Eloquent class does not extends the base one, but relates to it via ‘belongs-to’:

<?php

use Illuminate\Database\Eloquent\Model;
use Illuminate\Database\Eloquent\Relations\BelongsTo;
use Illuminatech\DbRole\InheritRole;

class Instructor extends Model // do not extend `Human`!
{
    use InheritRole;

    /**
     * {@inheritdoc}
     */
    protected $primaryKey = 'human_id';

    /**
     * {@inheritdoc}
     */
    public $incrementing = false;

    /**
     * Defines name of the relation to the master table
     * 
     * @return string
     */
    protected function roleRelationName(): string
    {
        return 'human';
    }

    /**
     * Defines attribute values, which should be automatically saved to 'humans' table
     * 
     * @return array
     */
    protected function roleMarkingAttributes(): array
    {
        return [
            'role' => 'instructor',
        ];
    }
    
    public function human(): BelongsTo
    {
        return $this->belongsTo(Human::class);
    }
}

This approach does not require extra Eloquent class for functioning, and it does not need default scope specification. It does not directly inherit logic declared in the base Eloquent model, however any custom method declared in the related class will be available via magic method __call() mechanism. Thus, if class Human has method sayHello(), you are able to invoke it through Instructor instance.

This approach should be chosen in case most functionality depends on the ‘Instructor’ attributes.

After being attached, \Illuminatech\DbRole\InheritRole provides access to the properties of the model bound by relation, which is specified via \Illuminatech\DbRole\InheritRole::roleRelationName(), as they were the main one:

<?php

$model = Student::query()->first();
echo $model->study_group_id; // equals to $model->studentRole->study_group_id

$model = Instructor::query()->first();
echo $model->name; // equals to $model->human->name

However, this will work only for the attributes, which have been explicitly defined at related model via \Illuminate\Database\Eloquent\Model::$fillable or \Illuminate\Database\Eloquent\Model::$guarded. Thus in order to make example from above function, classes used for the relations should be defined in following way:

<?php

use Illuminate\Database\Eloquent\Model;

class StudentRole extends Model
{
    protected $table = 'students';

    protected $primaryKey = 'human_id';

    public $incrementing = false;

    /**
     * All attributes listed here will be postponed to the role model
     */
    protected $fillable = [
        'study_group_id',
        'has_scholarship',
    ];

    /**
     * All attributes listed here will be postponed to the role model
     */
    protected $guarded = [
        'human_id',
    ];
    
    // ...
}

class Human extends Model
{
    protected $table = 'humans';

     /**
      * All attributes listed here will be postponed to the role model
      */
    protected $fillable = [
        'role',
        'name',
        'address',
    ];
    
    /**
     * All attributes listed here will be postponed to the role model
     */
    protected $guarded = [
        'id',
    ];
    
    // ...
}

If the related model does not exist, for example, in case of new record, it will be automatically instantiated on the first attempt to set role attribute:

<?php

$model = new Student();
$model->study_group_id = 12;
var_dump($model->studentRole); // outputs object

$model = new Instructor();
$model->name = 'John Doe';
var_dump($model->human); // outputs object

Any non-static method declared in the model related via \Illuminatech\DbRole\InheritRole::roleRelationName() can be accessed from the owner model:

<?php

use Illuminate\Database\Eloquent\Model;
use Illuminatech\DbRole\InheritRole;

class Human extends Model
{
    // ...

    public function sayHello($name)
    {
        return 'Hello, ' . $name;
    }
}

class Instructor extends Model
{
    use InheritRole;
    
    // ...
}

$model = new Instructor();
echo $model->sayHello('John'); // outputs: 'Hello, John'

This feature allows to inherit logic from the base role model in case of using ‘slave’ approach. However, this works both for the ‘master’ and ‘slave’ role approaches.

When main model is saved the related role model will be saved as well:

<?php

$model = new Student();
$model->name = 'John Doe';
$model->address = 'Wall Street, 12';
$model->study_group_id = 14;
$model->save(); // insert one record to the 'humans' table and one record - to the 'students' table

When main model is deleted related role model will be deleted as well:

<?php

$student = Student::query()->first();
$student->delete(); // Deletes one record from 'humans' table and one record from 'students' table

\Illuminatech\DbRole\InheritRole works through relations. Thus, in order to make role attributes feature work, it will perform an extra query to retrieve the role slave or master model, which may produce performance impact in case you are working with several models. In order to reduce number of queries you may use with() on the role relation:

<?php

$students = Student::query()->with('studentRole')->get(); // only 2 queries will be performed
foreach ($students as $student) {
    echo $student->study_group_id . '<br>';
}

$instructors = Instructor::query()->with('human')->get(); // only 2 queries will be performed
foreach ($instructors as $instructor) {
    echo $instructor->name . '<br>';
}

You may apply ‘with’ for the role relation as default scope for the Eloquent query:

<?php

use Illuminate\Database\Eloquent\Builder;
use Illuminate\Database\Eloquent\Model;

class Instructor extends Model
{
    protected static function boot()
    {
        parent::boot();

        static::addGlobalScope('with-role', function (Builder $builder) {
            $builder->with('human');
        });
    }
    
    // ...
}

Tip: you may name slave table primary key same as master one: use ‘id’ instead of ‘human_id’ for it. In this case conditions based on primary key will be always the same. However, this trick may cause extra troubles in case you are using joins for role relations at some point.

If you need to specify search condition based on fields from both entities and you are using relational database, you can use join() method.

Figuratively speaking, \Illuminatech\DbRole\InheritRole merges 2 Eloquent classes into a single one. This means you don’t need anything special, while creating web interface for their editing. However, you should remember to add role attributes to the \Illuminate\Database\Eloquent\Model::$fillable list in order to make them available for mass assignment.

<?php

use Illuminate\Database\Eloquent\Model;
use Illuminatech\DbRole\InheritRole;

class Instructor extends Model
{
    use InheritRole;

    protected $fillable = [
        // own fillable attributes:
        'rank_id',
        'salary',
        // role fillable attributes:
        'name',
        'address',
    ];

    // ...
}

Then controller, which performs the data storage may look like following:

<?php

use App\Http\Controllers\Controller;
use Illuminate\Http\Request;

class InstructorController extends Controller
{
    public function store(Request $request)
    {
        $validatedData = $request->validate([
            'salary' => ['required', 'number', 'min:0'],
            'rank_id' => ['required', 'string'],
            // role attributes
            'name' => ['required', 'string'],
            'address' => ['required', 'string'],
        ]);
        
        $item = new Instructor;
        $item->fill($validatedData); // single assignment covers both main model and role model
        $item->save(); // role model saved automatically
        
        // return response
    }
}

Simple & Powerful AI-Powered Lead Generation & Management for OpenAI’s GPTs . With our intuitive no-code solution, you can start leveraging business opportunities immediately.

Every small to medium-sized business and individual entrepreneur can instantly create an intelligent assistant using OpenAI’s GPTs. These assistants provide smart, convenient services to customers within minutes, enhancing user experience and engagement. But how do you capture and manage the valuable leads that your service generates?

Our platform empowers businesses and individual users to effortlessly collect, manage, and utilize leads without any need for coding or technical development. With our intuitive no-code solution, you can start leveraging business opportunities immediately.

Transform your GPTs into powerful lead generation tools with LeadGen-GPT. This guide outlines a straightforward, three-step process to enhance your digital services with advanced AI capabilities, ensuring you capture and manage leads effectively and efficiently.

1. Define Your Requirements
2. Connect Your GPTs
3. Receive Notifications and Monitor Your Leads

Please feel free to post issues or submit PRs to this repo and we will do our best to respond in a timely manner.

Simple & Powerful AI-Powered Lead Generation & Management for OpenAI’s GPTs . With our intuitive no-code solution, you can start leveraging business opportunities immediately.

Every small to medium-sized business and individual entrepreneur can instantly create an intelligent assistant using OpenAI’s GPTs. These assistants provide smart, convenient services to customers within minutes, enhancing user experience and engagement. But how do you capture and manage the valuable leads that your service generates?

Our platform empowers businesses and individual users to effortlessly collect, manage, and utilize leads without any need for coding or technical development. With our intuitive no-code solution, you can start leveraging business opportunities immediately.

Transform your GPTs into powerful lead generation tools with LeadGen-GPT. This guide outlines a straightforward, three-step process to enhance your digital services with advanced AI capabilities, ensuring you capture and manage leads effectively and efficiently.

1. Define Your Requirements
2. Connect Your GPTs
3. Receive Notifications and Monitor Your Leads

Please feel free to post issues or submit PRs to this repo and we will do our best to respond in a timely manner.

Install Jenkins in a EC2 instance Ubuntu 18.04 using ansible playbook. The following repos will be used:

• https://github.com/geerlingguy/ansible-role-java.git
• https://github.com/geerlingguy/ansible-role-jenkins.git

The main focus for this project is to prepare the EC2 instance with the required software to deploy, for this purpose ansible will be use to install jenkins

This project goal is to do a small example how to use this technology:

• Create a new user
• Provide roles to the new user
• Install an EC2 instance
• Install ansible
• Install java and jenkins software using ansible playbook

1. Create the user
2. Create a policy with the permissions to create an EC2 isntance
3. Configure the user in aws cli in your standalone environment
4. Create a KeyPair (For this case I use “jb_aws_keypair.pem”)

a. Configure the user in your aws cli

b. Create an EC2 instance using the Wizard

c. Connect to the EC2 instance and clone this repository in the EC2 instance

chmod 400 jb_aws_keypair.pem
ssh -i "jb_aws_keypair.pem" ubuntu@ec2-56-23-79-154.us-west-2.compute.amazonaws.com
git clone https://github.com/JoseBerrocal/Ansible_testing_project_02.git

d. Install Ansible

cd Ansible_testing_project_02
sh install_ansible.sh

e. Run Ansible

cd jenkins_ansible
ansible-playbook -i Inventory main.yaml

d. Access the URL of the EC2 instance, the output can be the following

To improve the project it will be required to install ansible in a first EC2 instance to later install jenkins in a different EC2 instance

中文

FEX allows you to run x86 applications on ARM64 Linux devices, similar to qemu-user and box64.
It offers broad compatibility with both 32-bit and 64-bit binaries, and it can be used alongside Wine/Proton to play Windows games.

It supports forwarding API calls to host system libraries like OpenGL or Vulkan to reduce emulation overhead.
An experimental code cache helps minimize in-game stuttering as much as possible.
Furthermore, a per-app configuration system allows tweaking performance per game, e.g. by skipping costly memory model emulation.
We also provide a user-friendly FEXConfig GUI to explore and change these settings.

FEX requires ARMv8.0+ hardware. It has been tested with the following Linux distributions, though others are likely to work as well:

• Arch Linux
• Fedora Linux
• openSUSE
• Ubuntu 22.04/24.04/24.10/25.04

An x86-64 RootFS is required and can be downloaded using our FEXRootFSFetcher tool for many distributions.
For other distributions you will need to generate your own RootFS (our wiki page might help).

Execute the following command in the terminal to install FEX through a PPA.

curl --silent https://raw.githubusercontent.com/FEX-Emu/FEX/main/Scripts/InstallFEX.py | python3

This command will walk you through installing FEX through a PPA, and downloading a RootFS for use with FEX.

Follow the guide on the official FEX-Emu Wiki here.

See the Source Outline for more information.