Saravanan666/pypi-org huggingface dataset:
Package: titanium
Titanium is light-weight evaluator for PMML models based on NumPy. With Titanium you are able to take predictive
model stored in pmml file, load it and start using it for making new predictions. It has the same API as you may know
when using widely known machine learning libraries likeKerasorscikit-learn- e.g.:predict_proba(X)predict_classes(X)It natively supports batch processing as input is expected to be 2D NumPy array. For list of supported models see bellow.The concept behind the name is that Titanium as the element is light and extremely durable material. Moreover it’s
resistant to corrosion - which has a parallel as mathematics behind the neural network evaluation using matrix
operations is above any particular implementations.InstallationTo install titanium, simply:$pipinstalltitaniumExampleExample on Iris data - for more examples see the examples folder.fromkeras2pmmlimportkeras2pmmlfromsklearn.datasetsimportload_irisimportnumpyasnpimporttheanofromsklearn.cross_validationimporttrain_test_splitfromsklearn.metricsimportaccuracy_scorefromkeras.utilsimportnp_utilsfromkeras.modelsimportSequentialfromkeras.layers.coreimportDensefromsklearn.preprocessingimportStandardScalerimporttitaniumastiimportosiris=load_iris()X=iris.datay=iris.targettheano.config.floatX='float32'X=X.astype(theano.config.floatX)y=y.astype(np.int32)X_train,X_test,y_train,y_test=train_test_split(X,y,test_size=.3)y_train_ohe=np_utils.to_categorical(y_train)y_test_ohe=np_utils.to_categorical(y_test)std=StandardScaler()X_train_scaled=std.fit_transform(X_train)X_test_scaled=std.transform(X_test)model=Sequential()model.add(Dense(input_dim=X_train_scaled.shape[1],output_dim=20,activation='tanh'))model.add(Dense(input_dim=20,output_dim=5,activation='tanh'))model.add(Dense(input_dim=5,output_dim=y_test_ohe.shape[1],activation='sigmoid'))model.compile(loss='categorical_crossentropy',optimizer='sgd')model.fit(X_train_scaled,y_train_ohe,nb_epoch=100,batch_size=1,verbose=3,validation_data=None)params={'copyright':'Václav Čadek','description':'Simple Keras model for Iris dataset.','model_name':'Iris Model'}keras2pmml(model,file='iris.pmml',**params)pmml=ti.read_pmml('iris.pmml')os.unlink('iris.pmml')keras_preds=model.predict_classes(X_test_scaled)titanium_preds=pmml.predict_classes(X_test_scaled)print('Accuracy (Keras):{accuracy}'.format(accuracy=accuracy_score(y_test,keras_preds)))print('Accuracy (Titanium):{accuracy}'.format(accuracy=accuracy_score(y_test,titanium_preds)))What is supported?Modelskeras.models.SequentialActivation functionstanhsigmoid/logisticLicenseThis software is licensed under MIT licence.https://opensource.org/licenses/MIT
Package: titanium-rhythm
Titanium-RhythmTitanium_Rhythm is a python package that recognizes mp3 files and automatically modifies its ID3.InstallationThis package requires:python-gst0.10-devgstreamer1.0libchromaprint-toolslibchromaprint-devpython-gst-1.0ffmpegInstall the above dependencies and required packages by:$apt-getupdate
$apt-getinstall<PACKAGES>
$pip3installtitanium-rhythmTests$pytestUsage>>> from titanium_rhythm.annotate import annotate_file
>>> annotate_file('PMaILC8xG3', filepath)or$ sudo python3 main.pyLicense: MIT
Package: titan-model
TITAN SimulationTITAN (Treatment of Infectious Transmissions through Agent-based Network) is an agent-based simulation model used to explore contact transmission in complex social networks. Starting with the initializing agent population, TITAN iterates over a series of stochastic interactions where agents can interact with one another, transmit infections through various medium, and enter and exit the care continuum. The purpose of TITAN is to evaluate the impact of prevention and treatment models on incidence and prevalence rates of the targeted disease(s) through the use of data fitting simulated trajectories and rich statistics of primary/sub-population attributable proportions.Agent populations are defined as graphs (nodes connected by edges). Nodes in the graph are used to represent the attributes (or collection of attributes) of an agent (person), and edges define the type of relationship between agents. In practice, a graph represents a social network of connected people through various relationship types, and provides the medium for which agents can interact.Getting StartedInstall the packagepip install titan-modelThis includes the scriptrun_titanwhich can then be used to run the model.PrerequisitesPython (or pypy) 3.6 or laterRunning the Modelrun_titan -p my_params.ymlTo run the model, execute therun_titanprogram. SeeTITAN paramsfor documentation on how to set and use parameters.Results of the model are generated and aggregated into the/results/directory by default. If the model is re-run, the existing results will be overwritten.Built WithPython3.x- Programming languageVan Rossum G, Drake FL. Python 3 Reference Manual. Scotts Valley, CA: CreateSpace; 2009.Networkx- Network structure backendHagberg A, Swart P, S Chult D. Exploring network structure, dynamics, and function using NetworkX. 2008.Numpy- Numerical librariesOliphant TE. A guide to NumPy. Vol. 1. Trelgol Publishing USA; 2006.AuthorsLars Seeman-Initial workMax King-Continued developmentSam Bessey-Continued developmentMary McGrath-Continued developmentLicenseThis project is licensed under the GNU General Public License version 3 - see theLICENSE.mdfile for details
Package: titanq
The titanQ SDK for PythontitanQ is the infinityQ Software Development Kit (SDK) for Python. The SDK facilitates and opens the way for faster implementation
of the titanQ solver without having to deal directly with the API.This titanq package is maintained and published byInfinityQAPI KeyIn order to use the titanQ service, a user needs an API key.
The API key can be obtained by contactingInfinityQ supportInstallationThe following steps assume that you have:AvalidandactiveAPI KeyA supported Python version installedSetting up an environmentpython-mvenv.venv
.venv/bin/activateInstall titanQpipinstalltitanqUsing titanQThe titanQ solver is designed to support very large problems and therefore very large files. To simplify the user experience, titanQ will instead use cloud storage set up and managed by the end users.Currently, the SDK only supports two types of storageStorage optionsVector variables limitS3 Buckets✅ Up to 100k vector variablesManaged storage⚠️ Up to 10k vector variablesBoth options are documented with examples at the titanQ'sQuickstart documentationProblem constructionNOTE:The weights matrix must be symmetrical.The QUBO problem is defined as finding the minimal energy configuration (the state $\mathbf{x}$ which results in the minimal $E(\mathbf{x})$).
Each state $\mathbf{x}$ is a vector of $n$ binary elements $x_i$ which can take the values of 0 or 1 (binary values).
This model formulation is given in the equation belowThe bias terms of a QUBO model are stored along the diagonal of the $\mathbf{Q}$ matrix. However, to simplify converting between Ising and QUBO models,
we assume that the diagonals of the $\mathbf{Q}$  matrix are 0, and take in an additional bias vector instead. To avoid confusion, the modified $\mathbf{Q}$  matrix with 0s
along its diagonal is referred to as theweightsmatrix, denoted bydenotes thebiases, which are used in the final model formulation described belowGetting support or helpFurther help can be obtained by contactingInfinityQ support
Package: titan-rhv
Install our codepip install titan-rhvpycurl (which is one of the dependencies) is not easy to install for both MacOS and Linux. Use google :)Create atitanrcto load the environment variables. You can
appened the content in your ~/.bash_profile (MacOS) or ~/.bashrc
(Linux)export TITAN_URL='https://lab-rhevm.microsoft.rdu.com/ovirt-engine/api'
export TITAN_USERNAME='adminuser@your_domain'
export TITAN_PASSWORD='password'
export TITAN_CA_FILE='ca.pem'
export TITAN_VM_PREFIX='your_user'
export TITAN_DEFAULT_TEMPLATE='your_preferred_template'Download ca.pem. Save the ca.pem to your preferred path and set
TITAN_CA_FILE correctly. For example, export
TITAN_CA_FILE=‘/root/ca.pem’$ wget '<Your RHV URL>/ovirt-engine/services/pki-resource?resource=ca-certificate&format=X509-PEM-CA' --no-check-certificate
$ mv pki-resource\?resource\=ca-certificate\&format\=X509-PEM-CA ca.pemSome examples$ titan -h
usage: titan [-h] {start,test,stop,show,delete,list,boot,console} ...

positional arguments:
  {start,test,stop,show,delete,list,boot,console}

optional arguments:
  -h, --help            show this help message and exit

# To list the VMs which filters by TITAN_VM_PREFIX environment variable
$ titan list
+--------------------------------------+--------------------------+--------+----------------+-----------------------------+
| ID                                   | Name                     | Status | Networks       | Comment                     |
+--------------------------------------+--------------------------+--------+----------------+-----------------------------+
| cd8212b3-f208-40b0-8f31-4140d57eac9b | cchen-7u4                | DOWN   |                | DNS server for all gss user |
| 89c9976f-fe53-49b4-b1fd-1e7a4b86a0e1 | cchen-7u5-template       | DOWN   |                |                             |
| 7f4ef4f8-1641-4145-8812-234dcec478e0 | cchen-desktop            | UP     | 10.72.37.242   |                             |
+--------------------------------------+--------------------------+--------+----------------+-----------------------------+

$ titan show cchen-desktop

+-------------+---------------------------------------------------------------------------------------+
| Item        | Value                                                                                 |
+-------------+---------------------------------------------------------------------------------------+
| Name        | cchen-desktop                                                                         |
| ID          | 7f4ef4f8-1641-4145-8812-234dcec478e0                                                  |
| Memory      | 8192M                                                                                 |
| CPU         | 4                                                                                     |
| Disks       | ['cchen-7u5-template_Disk1', 'ee9e366f-6930-4ab2-9eb7-095e4c22b0c7', '40G']           |
| Active Nics | ['nic1', '00:1a:4a:16:02:41', 'bcda0f88-eae7-4234-a897-5dafecc5856b', '10.72.37.242'] |
+-------------+---------------------------------------------------------------------------------------+
Package: titanscraper
TITANScraperv0.0.20DescriptionA web scraping library that makes scraping easy.
You can build complete web spiders and crawlers in a few lines of codeInstallationpip install titanscraperExampleAssuming you have installed the library using pip as above,
the next thing to do is to import the module and create an instance of theTitanScraperclassfromtitanscraperimportTitanScraperscraper=TitanScraper()Then you need to definerules. Rules are basically the instructions given to
the scraper to describe what to collect and name the data from a webpage. The most basic
structure of a rule is as follows:{"name":"item_name","selector":"some-css-selector",}The attributenamedescribes the name that will be given to specific data scraped from an
element that matches the selector inselector. Whereselectoris a valid CSS selector that actually references an HTML DOM element.For example, assuming you want to collect the price of an item from an e-commerce website
where the price of the product is found within aspanwith class namepricethat is in an article object with class nameproduct, you might want to do the following:{"name":"price","selector":"article.product > span.price",}Now you define your rules as a list as follows:RULES=[{"name":"product-title","selector":"article.product > span.name"},{"name":"product-price","selector":"article.product > span.price"}]The next thing to do is to define your target webpages. This is just a list of URLS#  define a list of all the web pages you intend to scraptarget_pages=["https://www.target_website.fr/target_one","https://www.target_website.fr/target_two",]With that set, now you can scrap the data from all the pages intarget_pagesand parse data using the rules defined inRULESabove as follows# start the scraping of the target webpages.data=scraper.scrap(target_pages,RULES)The data returned byTitanScraper.scrapis a list of dictionaries
where the keys are the values fromnameinRULESand the values are
the data collected from the correspondingselectorin the same rule.
Print your data to see what you have recieved as result.print(data)In normal circumstances (all pages scraped without error), the length of the listdatawill be equal to the length of the listtarget_pagesand the length of each item indatawill be the same as the number of rules inRULES.Check python scripts in/examplesdirectory to try real examples
Package: titantuner
TitantunerThe titantuner is a web interface for tuning the many parameters of quality control methods intitanlib.InstallationTitantuner is available on pypi, and can be installed as follows:pip3installtitantunerTo install from source, run the following in the root of this repository:pip3install.Running titantunertitantuner[-pport]This starts a webserver locally on your computer, making the titantuner available in the browser. Use-pto
speicy the port, otherwise it will appear on port 8081. Some sample data from Norwegian Synop stations are
provided by default.Select the test you want to perform (SCT, Isolation, Buddy, Buddy event, SCT resistant, SCT dual, First
Guess), and set the test parameters in the UI. Then click on the update button (below the parameters)
to see the map showing the results of the tests.Running titantuner on your own dataTitantuner can parse data files organzed as follows:lon;lat;elev;value
9.4023;61.5308;928;3.1
10.6878;60.0513;360;2.6where lat and lon are in degrees, elev in meters, and value is the measurement. Each row represents one
observation, and each file represents observations for one time.Supply a data directory when starting titantuner, which will load all data files in that directory:titantuner-d<datadir>Using the autotune function (beta version)Ongoing development. This function aims at finding optimized parameters for quality control methods. When
running the autotune function as it is, three parameters are optimized for the buddy check run on temperature
observations. These optimized parameters are the search radius, the minimum number of buddies a station can
have, and the variance threshold for flagging the station../titantuner/autotune.pyobs_ta_20230924T12Z.txtWith obs_ta_20230924T12Z.txt containing 5 columns of data (temperature values) following this format:lat;lon;elev;value;prid;dqc
61.1697;10.4107;205.0;13.70;5;0
58.2968;8.4620;70.0;14.60;5;7
Package: titan-zeus
zeusDocs are still lagging...What is this?This is a collection of tools extracted from a multi-project django monolith. Because we're new to publishing packages, there are a few gotchas:This is a monolithic package/install. Consumers can't just install a part, but must install the entire thing.This also means the whole thing is versioned together. If we add a shiny new feature after a totally independent breaking change, consumers can't get the new feature without the breaking change.This tool doesn't include external dependencies, you will have to install those yourself. We did this so consumers don't need to install packages they may not use.List of packages and utilitiesUtils are grouped by the following package names. That means you import them as so:fromzeus.vanillaimportis_asciivanillais_asciiare_strings_close_enoughgroup_byversioningversioning model behaviour has no external dependencies.Subclassingversioning.core.VersionModelwill create a history model that is automatically updated on each save. See theexamplechangelog(in progress)changelogs requires many external dependencies: graphene, aiodataloader, graphene-djangocreating changelogs currently require a lot of boilerplate code.TODO: create a function that abstracts away all the graphql and allows querying paginated changelog data for specific models, fields, users and dates.i18nDepends on django, bleach, mistune and pyyamlTextMakerCreator(global_keys,text_file_paths)WatchingTextMakerCreator((global_keys,text_file_paths)if usingrunserverandsettings.DEBUG=True, requires watchdogmarkdownrequires django, bleach and mistune to be installedmarkdownis_md_validsanitize_htmlInstallingpipinstalltitan-zeusInstalling from git with branchthe entry inrequirements.txtshould look like thisgit+git://github.com/TBS-EACPD/zeus@release-0.1#egg=zeusIf you installed using git and want to update, you'll need to runpip uninstall -y zeusbefore re-runningpip installBuildingHow to build dist and egginfo# in this project:pythonsetup.pysdistHow to install this locally without pypi (test this right before deploying a new version)editable modeWhen refreshing a local package, you'll also needpip uninstall -y zeusin between installs. This is super annoying, fortunately there's an easier way for python to link directly to the sources so this isn't necessary:pipuninstallzeus# then replace zeus in requirements.txt with the following# -e file:///absolute/path/to/zeus/locally packaged modeOnce you've got something that work in editable mode, try packaging the app# in zeus projectpythonsetup.pysdist# in consumer projectpipuninstall-yzeus# replace the zeus entry in requirements.txt with#file:///absolute/path/to/zeus/DevelopmentInstall postgres and configure your$PATHSet up the virtual environmentwe run tests against a postgres DB, so you'll need to runcreatedb zeus-dev
Package: titato
titatoLibrary of the game tic-tac-toe + AI.Experimental functionality with dynamic parameters of the game fieldFeatures:Unlimited number of players in one gameCreating a playing field of any size:With size parameters required:row,columnandwinning combinationArtificial Intelligence algorithm works with any game settings# Visualization of dynamic settings of the playing field10x10playervsplayervsplayer+-----+---+---+---+---+---+---+---+---+---+---+6x6playervsplayer|↓/→|0|1|2|3|4|5|6|7|8|9|+-----+---+---+---+---+---+---++-----+---+---+---+---+---+---+---+---+---+---+3x3playervsplayer|↓/→|0|1|2|3|4|5||0:|*|*|*|*|*|*|*|*|*|*|+-----+---+---+---++-----+---+---+---+---+---+---+|1:|X|*|*|*|*|*|*|O|*|*||↓/→|0|1|2||0:|*|*|*|*|X|*||2:|*|X|*|*|*|*|O|*|*|*|+-----+---+---+---+|1:|*|*|*|*|O|*||3:|*|*|P|*|*|P|*|*|*|*||0:|O|*|X||2:|*|*|*|*|O|*||4:|*|*|*|X|O|*|*|*|*|*||1:|*|O|*||3:|X|X|X|X|O|X||5:|*|*|*|O|X|*|*|*|*|*||2:|X|*|O||4:|*|*|*|*|O|*||6:|*|*|O|*|*|X|*|*|*|*|+-----+---+---+---+|5:|*|*|*|*|O|*||7:|*|O|*|*|*|*|X|*|O|*|+-----+---+---+---+---+---+---+|8:|O|*|*|*|*|*|*|*|*|*||9:|*|*|X|P|P|P|P|O|P|P|+-----+---+---+---+---+---+---+---+---+---+---+DocumentationDocumentation on GitHub
Package: ti-text
ti-textti-textis a Python package that provides a command-line interface for converting.8xpfiles to text and vice versa. This can be useful for TI-83/84 Plus calculator programming.InstallationYou can installti-textusing pip:pipinstallti-textUsageAfter installingti-text, you can use it from the command line like this:ti-textfile_pathprogram_nameReplace file_path and program_name with the actual file path and program name. It will automatically infer whether the file is binary or text and convert it to the other format.Building from sourceTo buildti-textfrom source, clone the repository and run the following command in the root directory of the project:pythonsetup.pysdistbdist_wheelLicenseti-textis licensed under the MIT License. SeeLICENSEfor more information.
Package: titiler.application
titiler.applicationTitiler's demo application.Installation$python-mpipinstall-Upip# From Pypi$python-mpipinstalltitiler.application# Or from sources$gitclonehttps://github.com/developmentseed/titiler.git
$cdtitiler&&python-mpipinstall-esrc/titiler/core-esrc/titiler/extensions-esrc/titiler/mosaic-esrc/titiler/applicationLaunch Application$python-mpipinstalluvicorn
$uvicorntitiler.application.main:app--reloadPackage structuretitiler/
 └── application/
    ├── tests/                   - Tests suite
    └── titiler/application/     - `application` namespace package
        ├── templates/
        |   └── index.html       - Landing page
        ├── main.py              - Main FastAPI application
        └── settings.py          - demo settings (cache, cors...)
Package: titiler.core
titiler.coreCore of Titiler's application. Contains blocks to create dynamic tile servers.Installation$python-mpipinstall-Upip# From Pypi$python-mpipinstalltitiler.core# Or from sources$gitclonehttps://github.com/developmentseed/titiler.git
$cdtitiler&&python-mpipinstall-esrc/titiler/coreHow TofromfastapiimportFastAPIfromtitiler.core.factoryimportTilerFactory# Create a FastAPI applicationapp=FastAPI(description="A lightweight Cloud Optimized GeoTIFF tile server",)# Create a set of COG endpointscog=TilerFactory()# Register the COG endpoints to the applicationapp.include_router(cog.router,tags=["Cloud Optimized GeoTIFF"])Seetitiler.applicationfor a full example.Package structuretitiler/
 └── core/
    ├── tests/                   - Tests suite
    └── titiler/core/            - `core` namespace package
        ├── algorithm/
        |   ├── base.py          - ABC Base Class for custom algorithms
        |   ├── dem.py           - Elevation data related algorithms
        |   └── index.py         - Simple band index algorithms
        ├── models/
        |   ├── response.py      - Titiler's response models
        |   ├── mapbox.py        - Mapbox TileJSON pydantic model
        |   └── OGC.py           - Open GeoSpatial Consortium pydantic models (TileMatrixSets...)
        ├── resources/
        |   ├── enums.py         - Titiler's enumerations (e.g MediaType)
        |   └── responses.py     - Custom Starlette's responses
        ├── templates/
        |   ├── map.html         - Simple Map viewer (built with leaflet)
        |   └── wmts.xml         - OGC WMTS document template
        ├── dependencies.py      - Titiler FastAPI's dependencies
        ├── errors.py            - Errors handler factory
        ├── middleware.py        - Starlette middlewares
        ├── factory.py           - Dynamic tiler endpoints factories
        ├── routing.py           - Custom APIRoute class
        └── utils.py             - Titiler utility functions