This repository is now archived because it has been merged into LedgerHQ/app-stellar.
Introduction
This is the wallet app for the Ledger Nano S, Ledger Nano S Plus and Ledger Nano X that makes it possible to store Stellar-based assets on those devices and generally sign any transaction for the Stellar network.
Documentation
This app follows the specification available in the ./docs folder.
SDK
You can communicate with the app through the following libraries:
If not for development purposes, you should install this app via Ledger Live.
To build and install the app on your Nano S or Nano S Plus you must set up the Ledger build environments. Please follow the load the application instructions at the Ledger developer portal.
Additionaly, install this dependency:
sudo apt install libbsd-dev
The command to compile and load the app onto the device is:
make load
To remove the app from the device do:
make delete
Testing
This project provides unit tests, integration tests and end-to-end tests, unit tests are located under the ./tests_unit folder, and the integration tests and end-to-end tests are located under the ./tests_zemu folder.
During development, we recommend that you run the unit test first, as it takes less time to run, and then run the other tests after the unit test has run successfully.
Unit testing
The ./tests_unit directory contains files for testing the utils, the xdr transaction parser, the screen formatter and the swap function.
Laravel is a web application framework with expressive, elegant syntax. We believe development must be an enjoyable and creative experience to be truly fulfilling. Laravel takes the pain out of development by easing common tasks used in many web projects, such as:
Laravel is accessible, powerful, and provides tools required for large, robust applications.
Learning Laravel
Laravel has the most extensive and thorough documentation and video tutorial library of all modern web application frameworks, making it a breeze to get started with the framework.
If you don’t feel like reading, Laracasts can help. Laracasts contains over 2000 video tutorials on a range of topics including Laravel, modern PHP, unit testing, and JavaScript. Boost your skills by digging into our comprehensive video library.
Laravel Sponsors
We would like to extend our thanks to the following sponsors for funding Laravel development. If you are interested in becoming a sponsor, please visit the Laravel Patreon page.
Thank you for considering contributing to the Laravel framework! The contribution guide can be found in the Laravel documentation.
Code of Conduct
In order to ensure that the Laravel community is welcoming to all, please review and abide by the Code of Conduct.
Security Vulnerabilities
If you discover a security vulnerability within Laravel, please send an e-mail to Taylor Otwell via taylor@laravel.com. All security vulnerabilities will be promptly addressed.
License
The Laravel framework is open-sourced software licensed under the MIT license.
This project is a simple implementation of a dark mode toggle switch for a webpage. When the switch is toggled on, the background color of the webpage changes to a dark theme, and the switch circle changes color as well. The implementation is done using HTML, CSS, and JavaScript. The HTML contains the switch input element and label, while the CSS is used to style the switch elements and animate the switch circle. The JavaScript code handles the functionality of the switch, updating the webpage’s background color and storing the user’s preference using local storage. The result is a basic but effective way to add a dark mode toggle feature to a webpage.
Demo
You can try out the application by visiting this link.
Technologies Used
HTML
CSS
JavaScript
Getting Started
To get started with this project, clone the repository and open the index.html file in your preferred web browser.
New Things I Learned
I learned about localStorage, which is a built-in web API that allows web developers to store data on a user’s local machine. It provides a simple way to save data locally and retrieve it later.
JSON.stringify(): I also learned about the JSON.stringify() method, which is a built-in JavaScript method that is used to convert a JavaScript object into a JSON string. JSON stands for JavaScript Object Notation and is a lightweight format for storing and transporting data.
localStorage.setItem(): Another thing I learned was the localStorage.setItem() method, which is used to store a key-value pair in the browser’s local storage. The setItem() method takes two arguments: the name of the key and the value you want to store.
localStorage.getItem(): I learned about the localStorage.getItem() method, which is used to retrieve a value stored in the browser’s local storage. The getItem() method takes the name of the key as an argument and returns the corresponding value.
JSON.parse(): I also learned about the JSON.parse() method, which is a built-in JavaScript method that is used to convert a JSON string back into a JavaScript object. This method is the opposite of JSON.stringify().
Overall, I learned about how to use localStorage to store and retrieve data on a user’s local machine, as well as how to use JSON.stringify() and JSON.parse() to convert data between a JavaScript object and a JSON string. These skills can be useful for building web applications that need to store and retrieve user preferences or other data on the user’s device.
Challenges I faced
I’ve had some difficulty understanding some of the JavaScript methods used in the code of this project. Specifically, I had trouble understanding localStorage.setItem(), localStorage.getItem(), and JSON.parse(), and how to use them in the context of the project.
cd dataset/IEMOCAP
python Preprocess.py --path $path to directory of IEMOCAP$
cd ../..
Then you have wavfeature_7.5.pkl and each processed audio is clipped to 7.5s and samped at 16kHz.
Training
We train the model specified in our paper with the same placement/proportion of shift. It should be noted that the placement/proportion of shift and other hyperparameters (see config.py) can be adjusted flexibly.
Key arguments for easy config modification in main.py are as follows,
--model: the model chosen for training.
cnn: convnext-like 1D CNN with 2 blocks.
rnn: 1 layer bidirectioanl LSTM.
transformer: 2-block Transformer with relative positional embedding by default.
--shift: whether to use temporal shift. The placement of shift are hard-coding as described in our paper: residual shift for CNN, replacement of MHSA for Transformer and in-place shift for lstm. We provide optional placement in annotation.
--ndiv: proportion of shift, namely 1/ndiv of channels will be shifted while others reamain unchanged.
--stride: the step to be shifted, kept as 1 by default.
--bidirectional: whether to use bidirectional temporal shift.
--finetune: whether to finetune the pretrained model or take the pretrained model as feature extractor. By default, we use wav2vec2 for finetuning and HuBERT for feature extraction.
The fianl results of 5 fold is expected to be in /log.
Citation
@inproceedings{shen2023mingling,
title={Mingling or misalignment? temporal shift for speech emotion recognition with pre-trained representations},
author={Shen, Siyuan and Liu, Feng and Zhou, Aimin},
booktitle={ICASSP 2023-2023 IEEE International Conference on Acoustics, Speech and Signal Processing (ICASSP)},
pages={1--5},
year={2023},
organization={IEEE}
}
In MS Excel, and Google Spreadsheets, literal ranges are denoted with opening and closing curly-brackets. E.g. “{1, 2, 3}”. In this implementation however, literal ranges are denoted with opening and closing brackets. E.g. “[1, 2, 3]”.
// OKsheet.setCell('A1','=SUM([1, 2, 3])');// NOT OKsheet.setCell('A1','=SUM({1, 2, 3})');
Docs
See DOCS.md for full list and documentation of all formulas available.
Contributing
When adding a formula, or fixing a bug please follow the commit message format:
[BUG_FEATURE_FILE_OR_COMPONENT] short description here of issue and fix
If you’re adding a new formula, before you submit a pull request or push ensure that:
The formula is tested inside the proper category file in tests/Formulas.
Make sure the formula is exported, and imported/exported in AllFormulas.ts.
The formula tests for reference errors, N/A errors, value errors for each input.
That the formula is tested for parsing inside SheetFormulaTest.ts.
Run tests with npm run test.
Build with npm run build.
Build DOCS.md with npm run docs.
Why?
Near the end of 2016 I began to ask myself why I didn’t know more about MS Excel and Google Spreadsheets. Why didn’t I know more about the most popular programing language in the world? I began to reverse engineer Google Spreadsheets in particular, gaining a better understanding along the way.
I chose TypeScript because, coming from Java, it is really nice to be able to see type errors, and catch them. I also just enjoy getting specific with my return types, even if the specifications for a spreadsheet treat type flexibly.
For the formula documentation, I tried to be at least — if not more — thorough as Google Spreadsheets.
License
For this repository’s code license, and related licenses, see LICENSES directory.
Standards was created to enable iOS, tvOS, watchOS and macOS developers that need to support legacy
systems (pre iOS 10.0, pre tvOS 10.0, pre watchOS 3.0 and pre macOS 10.12) to use the
Measurement API that’s included in
these systems’s Foundation.
Compatibility
iOS 8.0
tvOS 9.0
watchOS 2.0
macOS 10.10
Features
Compared to Measurement, Standards
has the following features:
Creating and Converting Standards (e.g. kilometers to miles)
Calculate with Standards (Operators +, -, *, /)
Compare Standards
Measurement Formatting
Compared to Measurement, Standards
supports the following Units:
Standards is designed to be API-compatible with Foundation on the call site. So you can just use
it like you would use Measurement,
with one exception:
For compatibility reasons with iOS 10.0+, tvOS 10.0+, watchOS 3.0+ and macOS 10.12+ it’s impractical
to actually call the class Measurement (b/c you then would always have to namespace it). So just
replace Measurement with Standard.
Basic Usage
letdistance=Standard(value:106.4, unit:UnitLength.kilometers)
// → 106.4 km
letdistanceInMeters= distance.converted(to:.meters)
// → 106400 m
letdistanceInMiles= distance.converted(to:.miles)
// → 66.1140591795394 mi
letdistanceInFurlongs= distance.converted(to:.furlongs)
// → 528.911158832419 fur
Installation
As for now, you can use Carthage or
CocoaPods to install Standards using a dependency manager or do it
manually.
Carthage
To integrate Standards into your Xcode project using Carthage, specify it in your Cartfile:
github "floriankrueger/Standards"
CocoaPods
Make sure your Podfile contains all of the following lines.
use_frameworks!platform:ios,'8.0'pod'Standards'
Then run pod install.
Manually
To do it ‘by hand’ take the following files and add them to your project:
This code can reproduce the experiment for CIFAR-10 dataset with the same setting of the GECCO 2017 paper (by default scenario). The (training) data are split into the training and validation data. The validation data are used for assigning the fitness to the generated architectures. We use the maximum validation accuracy in the last 10 epochs as the fitness value.
If you run with the ResSet described in the paper as the function set:
python exp_main.py -f ResSet
Or if you run with the ConvSet described in the paper:
python exp_main.py -f ConvSet
When you use the multiple GPUs, please specify the -g option:
python exp_main.py -f ConvSet -g 2
After the execution, the files, network_info.pickle and log_cgp.txt will be generated. The file network_info.pickle contains the information for Cartegian genetic programming (CGP) and log_cgp.txt contains the log of the optimization and discovered CNN architecture’s genotype lists.
Some parameters (e.g., # rows and columns of CGP, and # epochs) can easily change by modifying the arguments in the script exp_main.py.
Re-training
The discovered architecture is re-trained by the different training scheme (500 epoch training with momentum SGD) to polish up the network parameters. All training data are used for re-training, and the accuracy for the test data set is reported.
Groupie is een software service that enables groups to administer their
members, on which ARPA2 applications can continue to build their
collaborative structures. Groupie administers things over email, using
the fact that the majority of email is signed by DKIM.
Groupie allows users to setup groups under their domain, and invite members
into their groups. Members can address services for subscribing to a group.
Only when the group owner and the member agree will the membership be a fact.
Specifically, the design of the InternetWide Architecture involves storage
of information in an LDAP repository, which is centrally available and which
can be easily distributed to other players, would the need arise. This is
the Service Directory
that is a vital part in the backend of this hosting infrastructure.
Juggling Group Identities as in ARPA2 Projects
ARPA2 defines users as well as groups, but that is not everything; it allows
a great number of controls over light-weight aliases, and uses that heavily
in protection of the privacy of users.
Please understand that nothing about ARPA2 is closed or secretive;
in fact, we are hoping to inspire many Internet service projects to integrate
their use of identity with the system we are building to achieve better
personal control over our online identity and, most importantly, better
integration between tools.
Even in a group, the user does not have to surrender their userid or even
their (remote) email address. Group members have a membership name which
is represented as a refinement of the group name, pretty much just like
the aliases. The idea is that group members can address each other by
referring not to the group, but by adding member names to it. This is
simpler than it seems; communication in the group will come From: a
particular group member, thereby revealing their group identity. All
ARPA2 systems can work with this, and only the group-support software is
really involved in mapping between those group member names and real local
aliases and/or remote email addresses.
So, imagine john@example.com signing up for youcancook@example.com, so
locally. John picks an alias, youcancook+charcoalman@example.com for
his membership to the list (or he might leave it to the limited fantasy
of Groupie, which usually means that he ends up with 043510-04363 or
something similarly appealing.
When communicating on the list, John always has a choice or replying to
a sender or to all on the list. In addition, there is some syntaxis
that allows sending to the list plus selected dormant members, or minus
a member whose birthday surpirse needs to be discussed. Often, there
will be a group member named record which stores everything that
passes for future reference. Sometimes, an dormant group member nsa
(short for Non-Subscriber-Archive) may be added in to make an exchange
available publicly. All this ends up in addresses with local parts
like youcancook+mary for just Mary, youcancook for the entire group
of non-dormant members, and youcancook+-+record for off-the-record
talk.
Mary, by the way, may be a remote member. The member name mary in youcancook+mary does not show that; a good example of how the member
names help to protect privacy of group members. WHo’s who is however
known to the group owner, who might need it to tackle abuse.
Mechanics from LMTP to LDAP
Requests arrive with Groupie over an LMTP port. This is a customary backend
to which MTAs can send email. Such email will have a human sender, and it
will be delivered to an identity known to Groupie. These identities look
something like +group+subscribe+piecrusts@baking.fun — in other
words, an email address under a domain, with a few words in the local part.
After splitting the words by their + separators, they look like commands.
Groupie will ignore the first word, which is the service name that it got
from the MTA administrator, but after that has served the purpose of routing
email to Groupie’s LMTP port that is no longer of interest. The rest is
a command and parameters, usually a name of a group under the domain that
follows after @.
These commands are used to operate on data structures stored in LDAP.
Specifically, LDAP holds nodes for groups, with more specific nodes
for group members. These group members point to a local alias or a
complete remote address for a remote user. Note that a remote address
is an email address, or similar user@domain style notation. This is
the form that we always use in ARPA2 Projects.
The commands that Groupie supports are focussed on editing these structures
in LDAP, and given that understanding the work done by Groupie is really
very simple; it takes in email, derives a command from it, and applies it
to the Service Directory LDAP. Its findings may be reported back to the
requester.
It’s Elementary, My Dear Watson
The reasons that Groupie’s functions are elementary is that all use of the
group structures is done elsewhere. This is vital, because there could be any
number of protocols implementing collaborative semantics with group sharing.
So, Groupie does not administer email groups, but rather leaves that to a
separate component. This often takes the form of a SteamWorks Pulley
application with a suitable script
to extract the group membership relations from LDAP and, through a simple Pulley Backend
that delivers the relations analysed from LDAP to an application. If you
want your groups to end up in a couple of DBM databases for use by Postfix,
then you can easily build that.
So, all that Groupie needs to care about is adding and removing group
members. Given the structures for groups
with separate acceptance of a member by a group and of a group by a member,
it is even really straightforward to do this.
It is not a coincidence that the task of Groupie is so elementary. It is a
result of our conscious choice to use LDAP, with its rich semantics, fine
data model and precondition-protected atomic updates of fairly complex objects.
It is also not a shrugging matter that Groupie is so elementary;
there can be other interfaces to the same backend, especially SteamWorks Crank
maps LDAP objects into a the HTTP space through JSON and a RESTful interface.
The authentication and authorisation mechanisms may differ, but access to
the underlying data model is… elementary. And it is also relatively easy
to keep the two models in sync.
Why do we need Groupie when we can have the interactive marvels of a web
interface? Obviously not because we like to be retro. Groupie provides us
with a bootstrapping mechanism for secure administration of a website. With
DKIM readily available to anyone, it is now possible to make reasonable
assumptions about the authenticity of users, even those that are external
to ARPA2 tooling.
Secure Access to Groupie
If there’s anything that Groupie will not tolerate, it is insecure access
attempts. The old-school approach to security to list membership is to
send back an email with a code that has to be replicated by the receiver
either in a reply email or through a web link. Groupie is willing and able
to be retro, by falling back to those procedures of last century. But it has
not been idling around since those old days, and has evolved.
Today, many users have their email signed silently with DKIM. In fact, the
most probably place where this is done is at the origin, so at their email
sending service provider. This is great news, because whatever is protected
by DKIM cannot change while it passes through. Combine that with the habit
of TLS-encrypted connections and the common ability to pass mail directly
from the sender domain to the recipient domain, and we have a pretty secure
setup.
DKIM signs email bodies as well as a selection of headers. The selection
is dynamic, and determined by the signer, so the email message originator.
Usually, the To: and Cc: headers are signed, as is the From: address
and the Subject: line. In short, we have some really interesting information
to act on (and we can always fall back on retro practices if we need to).
When a messages arrives over LMTP, the MTA should set a header to the
original email address, holding the +group+subscribe+bla@talks.cheap style
address for the Groupie service. This address is (or these addresses are)
used to sum up one or more actions to perform. Let’s take Postfix as an
example, and say that the Groupie service is in the X-Original-To: header.
The addresses provided in X-Original-To: are not of any cryptographic
standing. They really need to be validated in some way. This can be
done by validating that it has occurred in a DKIM-signed header. If not,
it may have been supplied in an unsigned header, in which case retro security
needs to kick in.
The other bit of information that we are interested in, is the sender of
the message. DKIM can validate a sender domain, and we shall make the
(not too) liberal assumption that the domain feels better than to allow one
user to fake the identity of another. In fact, it is up to the domain how
well it wants to be protected. DKIM key material with or without protection
by DNSSEC, it is a choice that would reflect back on the security of the
group members. Anyhow, the vital point is that the sender address can be
learned reliably from the From: header, which is also customarily
signed with a DKIM-Signature: — and if not, Groupie zaps back to
retro times.
Given an authenticated command and sender, Groupie can perform most of
its tasks. For some tasks it requires the owner to be the sender. For
others, anyone is welcome. Yet others require group membership. In some
of the cases, the Subject: is needed, of course under protection from
the DKIM-Signature: or else… back to old times and bad habits.
(The Subject: is sometimes used to contain a requested member name.)
Supported Commands
Groupie supports the following commands, which we shall write in the
form after splitting over the + symbols:
group help [<group>] requests information [about <group>] by
reply mail.
group subscribe <group> and group unsubscribe <group> add or
remove a member from <group>. The member name is randomly
picked by Groupie or, given a secure Subject: header with a <group>+<member> name, it will try to use that member name.
The command group decline <group> is an explicit but negative
form of subscription.
group invite <group> and group uninvite <group> are used by
the group owner to invite members. There is an explicit negative
form as well, group refuse <group>. The body of the email is
formed as lines holding one email address each, and then when a
message should be sent to the victims, an empty line and the
message to send. Only plaintext bodies are processed, the rest
is stripped away because processing it is errprone and may be
harmful by leaking email addresses between members.
There is bound to be a facility for listing group members, as
people always seem to feel comfort in breaching either privacy
or security. Given that the membership names are relatively
private already, this may not be a high-value commodity, even
though it would be for spammers who need contact end points.
A few more commands for adminsitrative purposes are bound to
arise. It may be beneficial to create groups over mail, for
example. Time will tell and ACLs will be in the way.
As mentioned before, the group part of this command is not valuable;
consider it your argv[0] name indication, a thing to use in result
printouts but never something on which to build value.
Cashier-App is a web-based cashier application built using React and other technologies such as API and JSONPlaceholder. The application is designed to help manage sales transactions easily and efficiently.
Feature
ReactJS: Built with React for a responsive and interactive UI.
API Integration: Uses APIs to fetch and manage product and transaction data.
JSONPlaceholder: Provides dummy data for testing and development.
–Dynamic UI: A dynamically updatable interface based on data retrieved from the API.
Installation
Make sure you have installed Node.js dan npm on your system.
Welcome to the PublicAPI_Hub_API! This Node.js application, built with Express, serves a curated list of public APIs available across various categories. Explore different categories and discover the APIs within them.
https://github.com/overcat/ledger-stellar
