Saravanan666/pypi-org huggingface dataset:
Package: itechpsp-sdk
ITechPSP payment page SDKThis is a set of libraries in the Python language to ease integration of your service
with the ITechPSP Payment Page.Please note that for correct SDK operating you must have at least Python 3.5.Payment flowInstallationInstall with pippipinstallitechpsp-sdkGet URL for paymentfrompayment_page_sdk.gateimportGatefrompayment_page_sdk.paymentimportPaymentgate=Gate('secret')payment=Payment('402')payment.payment_id='some payment id'payment.payment_amount=1001payment.payment_currency='USD'payment_url=gate.get_purchase_payment_page_url(payment)payment_urlhere is the signed URL.Handle callback from ITechPSPYou'll need to autoload this code in order to handle notifications:frompayment_page_sdk.gateimportGategate=Gate('secret')callback=gate.handle_callback(data)datais the JSON data received from payment system;callbackis the Callback object describing properties received from payment system;callbackimplements these methods:callback.get_payment_status()Get payment status.callback.get_payment()Get all payment data.callback.get_payment_id()Get payment ID in your system.
Package: itech_serial
ITECH serial library for PythonControl ITECH test equipment using a proprietary 26-byte UART protocol.You'll need tomake your own adapterto connect your test equipment to your computer, or presumably buy an
isolated one.Note: If your test equipment has a USB port, use that instead! The -A and -B
variants of some ITECH product lines have an optional USB port, which is
is supported by standard USBTMC libraries such as pyvisa. This library
is intended for devices that only implement a proprietary control protocol
over a TTL serial port.UsageFirst, install the library from pypi:pip install itech_serialThen, assuming you have an IT8511 load, and it is connected to your computer
using a USB-to-serial converter that was identified as /dev/ttyUSB0, you can
open a connection to it like this:from itech_serial import IT8500
load = IT8500('/dev/ttyUSB0')During connection, the library will check that the device identify matches a
known string. If you have different equipment  that speaks the same protocol
(such as a BK Precision load), please create an issue on GitHub with the
device details and the reported string.Once the connection is made, you first need to enable remote control to allow
the device to be controlled over serial:load.control_set_remote()Next, you can set the device to (for example) a 0.5A constant current load:load.mode_set('cc')
load.constant_current_set(0.5)
load.enable()You can then read back the measured voltage and current that the load sees:print(load.measure)When you are done, be sure to turn the load off, and (optionally) set the
device control back to local to allow the front panel buttons to work again:load.disable()
load.control_set_local()Identifying a specific USB deviceIf you know what USB to serial converter is connected to your instrument, you
can use the find_usb() function to locate it by VID, PID, and optionally
serial number:from itech_serial import find_usb
load = IT8500(find_usb(vid=0x10c4, pid=0xea60, serial_number='00F84E81')[0])This is especially helpful for situations where you have multiple instruments
connected to a single computer, and need a reliable way to connect to the
correct one.
Package: iteda
Integrating sphere how to ReadmeAuthor(s)Victor EsparzaFabrizio Di FrancescoGetting StartedThese instructions will get you a copy of the project up and running on
your local machine for development and testing purposes. See deployment
for notes on how to deploy the project on your system.### PrerequisitesWhat things you need to install the software and how to install them:* Python 2.7 and or 3.7.1 (latest version) * pip (latest version) The
rest of the needed packages is going to be installed as a dependency
from pip repo.Installing processNavigate to pip repopipAll you need is to execute the command displayed in your favourite
terminal.Using Iteda software (Linux)We only support linux systems, if you need to change some setings about the serial port configuration, please edit the menu.c file included and compile it.Compilationopen a terminal
Navigate to the directory where the file is located and compile it like this>
cc  -o menu menu.cUnix/Linuxopen a terminal
python ## execute python terminal (python 2)
from iteda import iteda  ## now we import the program
iteda.main()  ## execute the menuVersioningWe useGitKrakenfor versioning.AcknowledgmentsA big thank you to all the iteda team
Package: item
Usage ExamplefromitemimportItemfromlxml.htmlimportfromstringclassSomeStructure(Item):id=IntegerField('//path/to/@id')name=StringField('//path/to/name')date=DateTimeField('//path/to/@datetime','%Y-%m-%d%H:%M:%S')structure=SomeStructure(fromstring(SOME_HTML))print(structure.id)print(structure.name)print(structure.date)Installationpipinstallitem
Package: itembed
itembed— Item embeddingsThis is yet another variation of the well-known word2vec method, proposed by Mikolov et al., applied to unordered sequences, which are commonly referred as itemsets.
The contribution ofitembedis twofold:Modifying the base algorithm to handle unordered sequences, which has an impact on the definition of context windows;Using the two embedding sets introduced in word2vec for supervised learning.A similar philosophy is described by Wu et al. in StarSpace and by Barkan and Koenigstein in item2vec.itembeduses Numba to achieve high performances.Getting startedInstall fromPyPI:pip install itembedOr install from source, to ensure latest version:pip install git+https://github.com/sdsc-innovation/itembed.gitPlease refer to thedocumentationfor detailed explanations and examples.
Package: itemizer
[![Latest Version](https://pypip.in/version/itemizer/badge.svg)](https://pypi.python.org/pypi/itemizer/)
[![Downloads](https://pypip.in/download/itemizer/badge.svg)](https://pypi.python.org/pypi/itemizer/)
[![Supported Python versions](https://pypip.in/py_versions/itemizer/badge.svg)](https://pypi.python.org/pypi/itemizer/)
[![Development Status](https://pypip.in/status/itemizer/badge.svg)](https://pypi.python.org/pypi/itemizer/)
[![License](https://pypip.in/license/itemizer/badge.svg)](https://pypi.python.org/pypi/itemizer/)itemizerA [dmenu](http://tools.suckless.org/dmenu/) wrapper script that:Lets you define menu items askey: valuepairs in a
[YAML](http://yaml.org/) file, like:Firefox: firefox
Terminal: gnome-terminal
Nautilus: nautilus –no-desktop –new-windowThe keys are what will be shown in dmenu. The values are the commands that
will be run when you select the keys from dmenu. Unlike the usual way of
using dmenu, the items shown in the menu don’t have to be the same as the
commands executed when they’re selected.Sorts the items in dmenu most-recently-used first (not yet implemented!)InstallationFirst install dmenu, then:pip install itemizerUsageitemizer_runIt accepts all the same command-line arguments as dmenu:itemizer_run -f -i -nb “#222222” -nf “#bbbbbb” -sb “#005577” -sf “#eeeeee” -fn “--terminus-medium-r---16-------”To customize the menu copy the [default itemizer.yaml file](itemizer/itemizer.yaml) to~/.itemizer.yamland edit it.Itemizer is composed of two subcommands:itemizer listprints a newline-separated list of all the keys from your
items file to stdout, suitable for piping into dmenu.itemizer showreads a key from stdin, looks up its value in your items
file, and prints it to stdout. Pipe the output from dmenu intoitemizer show, then pipe the ouput fromitemizer showtosh.Runitemizer -hfor complete documentation of the options and subcommands.[itemizer_run](bin/itemizer_run) is a shell script that tiesitemizer list,dmenu,itemizer showandshtogether, and that passes any command-line arguments
that you pass it on to dmenu.
Package: itemloaders
itemloadersis a library that helps you collect data from HTML and XML sources.It comes in handy to extract data from web pages, as it supports
data extraction using CSS and XPath Selectors.It’s specially useful when you need to standardize the data from many sources.
For example, it allows you to have all your casting and parsing rules in a
single place.Here is an example to get you started:from itemloaders import ItemLoader
from parsel import Selector

html_data = '''
<!DOCTYPE html>
<html>
    <head>
        <title>Some random product page</title>
    </head>
    <body>
        <div class="product_name">Some random product page</div>
        <p id="price">$ 100.12</p>
    </body>
</html>
'''
loader = ItemLoader(selector=Selector(html_data))
loader.add_xpath('name', '//div[@class="product_name"]/text()')
loader.add_xpath('name', '//div[@class="product_title"]/text()')
loader.add_css('price', '#price::text')
loader.add_value('last_updated', 'today') # you can also use literal values
item = loader.load_item()
item
# {'name': ['Some random product page'], 'price': ['$ 100.12'], 'last_updated': ['today']}For more information, check out thedocumentation.ContributingAll contributions are welcome!If you want to review some code, check openPull Requests hereIf you want to submit a code changeFile anissue here, if there isn’t one yetFork this repositoryCreate a branch to work on your changesRunpre-commit installto install pre-commit hooksPush your local branch and submit a Pull Request
Package: itemseg
itemseg10-K Item Segmentation with Line-based Attention (ISLA) is a tool to process
EDGAR 10-K reports and extract item-specific text.Table of ContentsInstallationLicenseInstallationpip3 install itemsegDownload resource filepython3 -m itemseg --get_resourceDownload nltk dataLaunch python3 console>>> import nltk>>> nltk.download('punkt')Segment items in a 10-K fileUsing Apple 10-K (2023) as an example:python3 -m itemseg --input https://www.sec.gov/Archives/edgar/data/320193/000032019323000106/0000320193-23-000106.txtSee the results in ./segout01/The *.csv file contain line-by-line prediction for items in a Begin-Inside-Outside (BIO) style tags. Other files contain item-sepcific text. Change output file types via--outfn_type.About 10-K files.A 10-K report is an annual report filed by publicly traded companies with the U.S. Securities and Exchange Commission (SEC). It provides a comprehensive overview of the company's financial performance and is more detailed than an annual report. Key items of a 10-K report include:Item 1 (Business): Describes the company's main operations, products, and services.Item 1A (Risk Factors): Outlines risks that could affect the company's business, financial condition, or operating results.Item 3 (Legal Proceedings)Item 7 (Management’s Discussion and Analysis of Financial Condition and Results of Operations; MD&A): Offers management's perspective on the financial results, including discussion of liquidity, capital resources, and results of operations.You can search and read 10-K reports through theEDGAR web interface. The itemseg module takes the URL of theComplete submission text file, convert the HTML to formated txt file, and segment the txt file by items.As an example, the AMAZON 10-K report page forfiscal year 2022shows the link to the HTML 10-K report and aComplete submission text file0001018724-23-000004.txt. Pass this link (https://www.sec.gov/Archives/edgar/data/1018724/000101872423000004/0001018724-23-000004.txt) to the itemseg module, and it will retrive the file and segment items for you.python3 -m itemseg --input https://www.sec.gov/Archives/edgar/data/1018724/000101872423000004/0001018724-23-000004.txtThe default setting is to output line-by-line tag (BIO style) in a csv file, together with Item 1, Item 1A, Item 3, and Item 7 in separate files (--outfn_type "csv,item1,item1a,item3,item7"). You can change output file type combination with --outfn_type. For example, if you only want to output Item 1A and Item 7, then set --outfn_type "item1a,item7".If you are trying to process large amounts of 10-K files, a good starting point is the master index (https://www.sec.gov/Archives/edgar/full-index/), which lists all available files and provides a convenient venue to construct a comprehensive list of target files.The module also comes with a script file that allow you to run the module viaitemsegcommand. The default location (for Ubuntu) is at ~/.local/bin. Add this location to your path to enableitemsegcommand.Licenseitemsegis distributed under the terms of theCC BY-NClicense.
Package: itemset-mining
Itemset MiningImplements itemset mining algorithms.AlgorithmsHigh-utility itemset mining (HUIM)HUIM generalizes the problem of frequent itemset mining (FIM) by considering item values and weights. A popular application of HUIM is to discover all sets of items purchased together by customers that yield a high profit for the retailer. In such a case, item values would show not just that a load of bread is in a basket, but how many there are; and weights would include the profit from a loaf of bread.More technically, HUIM requires transactions in the transactions "database" to have internal utilities (i.e. item values) associated with each item in each transaction and a "database" of external utilities for each item (i.e. weights).AlgorithmClassHow to CiteTwo-Phase*itemset_mining.two_phase_huim.TwoPhaseLink* Includes max length supportRoadmap (high to low priority):Address low-correlation HUIs with one of bond, all-confidence, or affinity.Itemsets that are high utility, but where the items aren't correlated can be misleading for making marketing decisions. E.g. if an itemset of a TV and a pen is a HUI, it's likely just because the TV is expensive, not because it's an interesting pattern.Addaverageutility measure support, for easier, more intuitive minutilSupport discount strategiesvia a discount strategy table and upgraded external utilities table.Add top-k HUI support.Support identifying periodic high utility itemsets.This allows detection of purchase patterns among high-utility itemsets to allow cross-promotions to customers who buy sets of items periodically.Support items' on-shelf time.Ignmoring on-shelf time will biat toward items that have more shelf time, since they have more chance to generate higher utility.Allow incremental transaction updateswithout rerunning everything.Support concise HUI itemsets, specifically closed form.This allows the algorithm to be more efficient, only showing longer itemsets, which may be the most interesting ones (correlation issues aside).Installation:pipinstallitemset-miningExample:>>>fromoperatorimportattrgetter>>>fromitemset_mining.two_phase_huimimportTwoPhase>>>transactions=[...[("Coke 12oz",6),("Chips",2),("Dip",1)],...[("Coke 12oz",1)],...[("Coke 12oz",2),("Chips",1),("Filet Mignon 1lb",1)],...[("Chips",1)],...[("Chips",2)],...[("Coke 12oz",6),("Chips",1)]...]>>># ARP for each item>>>external_utilities={..."Coke 12oz":1.29,..."Chips":2.99,..."Dip":3.49,..."Filet Mignon 1lb":22.99...}>>># Minimum dollar value generated by an itemset we care about across all transactions>>>minutil=20.00>>>hui=TwoPhase(transactions,external_utilities,minutil)>>>result=hui.get_hui()>>>sorted(result,key=attrgetter('itemset_utility'),reverse=True)...# doctest: +NORMALIZE_WHITESPACE[HUIRecord(items=('Chips','Coke 12oz'),itemset_utility=30.02),HUIRecord(items=('Chips','Coke 12oz','Filet Mignon 1lb'),itemset_utility=28.56),HUIRecord(items=('Chips','Filet Mignon 1lb'),itemset_utility=25.979999999999997),HUIRecord(items=('Coke 12oz','Filet Mignon 1lb'),itemset_utility=25.57),HUIRecord(items=('Filet Mignon 1lb',),itemset_utility=22.99),HUIRecord(items=('Chips',),itemset_utility=20.93)]
Package: item-tracking
item_trackingOverviewThis is a tracking package for items, which are define with a complete structure.
Item can be define either by PointCloud as define in ROS, or with components.
These components have 3D pose, orientation and size.
It is possible to enable pose smoothing of components or item. The implemented smoothing is exponential smoothing.
The tracking matches check each iteration the evolution of tracked items depending on how the parameters are set.ExamplesExamples of how this package can be used are in the directory examples.Installationpip install item_trackingshould work for most users.
Package: it-eng-python-logger-utils-dev-pypi
Quick set up (dev)pip3 install it-eng-python-logger-utils-devImport thelogger_utils.pylibraryfromit_eng_python_logger_utils.logger_utilsimportLoggerHelperlogger=LoggerHelper("Logger_Test",<app_insights_token>or"","INFO")logger.info("Hello wurld!")When deployed to moda we should be pulling the octofactory packeoctofactory package hereRequirements included with packageopencensus-ext-azurerequestsopencensus-ext-requestsContributeMake your changes (remember to update the version to1.x.xin thesetup.py)Build your packagemake buildBootstrap your packagemake bootstrapTest your packagepython3 test/test.pyBe a good housekeepermake cleanupUpload your packagemake uploadTest out your package by pulling from pypiWinIf you're getting a lot of installs from cache, anoptionalsuggestion is to clear your pip cache so you know you're working with a fresh version install of the package and dependencies. But this is totally optional and only suggested if you're running into consitency issues.To find your pip cache -pip3 cache direx:rm -rf /Users/<user>/Library/Caches/pipClass instantiationWhen initializing our logger class, we have three parameters and one optional:Logger_name :requiredstring- this should be your app/job nameLevel :optionalstring- this should be the level of logs you wish to be displayed to console. Ex: If set toINFO or DEBUG(with debug being incredibly granular) all log messages no matter the level will be logged. If set toCRITICAL, only critical messages will be logged.App insights token :optionalstring- Your instrementationkey onlyif you pass the connection string you will receive anexception.Send_to_azure: optionalboolean- defaulted toTrue. Sends your logs to Azure app insights if you have an instrumentation key initilized.Method Parametersexample:logger.info('your message')messageany- the message you want to send to Azure app insights/logged in your app.structuredboolean- defaulted toTrue. When set toTrueyourmessageswill structure your log with a default JSON structure which includes information to signify what job the logs came from, the severity and message. The JSON structure allows us to parse Splunk and Azure app insights logs with more clarity and granularity by formatting everything by a JSON key/value. To enable the JSON log structure in splunk, update your jobsdeployments/{job}.yamlto use JSON viafluentbit.io/parser: jsonTroubleshootingIf you're not usre if your package is getting installed correct, you can check the package contents with:pip show -f <package>Uninstall all packagespip freeze | cut -d "@" -f1 | xargs pip uninstall -yrm -rf /Users/dinnermonster/Library/Caches/pip
Package: it-eng-python-logger-utils-dev-pypi1
Logger UtilityIncluded with the IT-Offboarding suite is a custom logger library located in./lib/logger_utils.pythat standardizes our logs and sends them to azure app insights. The library utilizes the native pythonlogginglibrary and functions similarly to the native library.
When the class is initialized in our scripts, the logger library also logs all API call information automatically and sends them to Azure app insights.To useRequirementsopencensus-ext-azureopencensus-ext-requestsImport the logger_utils.py library<<<<<<< HEADfrom it_eng_python_logger_utils.logger_utils import Logger_Helperlogger = Logger_Helper("Logger_Test", "INFO")SetAPPI_TOKENto your app insights instrumentation key in your .envClass initializationWhen initializing our logger class, we have two parameters:logger_namestring- this should be your app/job namebasicConfigstring- this should be the level of logs you wish to be displayed to console. Ex: If set toINFO or DEBUG(with debug being incredibly granular) all log messages no matter the level will be logged. If set toCRITICAL, only critical messages will be logged.send_to_azureboolean- defaulted toTrue. Sends your logs to Azure app insights.
=======from path.to.logger_utils import Logger_Helperlogger = Logger_Helper("Logger_Test", <InsightsToken>, "INFO")Class initializationWhen initializing our logger class, we have three parameters and one optional:Logger_name :requiredstring- this should be your app/job nameApp insights token :required - Your instrementationkey onlyif you pass the string you will receive anexception.Level :requiredstring- this should be the level of logs you wish to be displayed to console. Ex: If set toINFO or DEBUG(with debug being incredibly granular) all log messages no matter the level will be logged. If set toCRITICAL, only critical messages will be logged.Send_to_azure: optionalboolean- defaulted toTrue. Sends your logs to Azure app insights.dev-pypiMethod Parametersexample:logger.info('your message')<<<<<<< HEADmessagedictorstring- the message you want to send to Azure app insights/logged in your app.
=======messageany- the message you want to send to Azure app insights/logged in your app.dev-pypistructuredboolean- defaulted toTrue. When set toTrueyourmessageswill structure your log with a default JSON structure which includes information to signify what job the logs came from, the severity and message. The JSON structure allows us to parse Splunk and Azure app insights logs with more clarity and granularity by formatting everything by a JSON key/value. To enable the JSON log structure in splunk, update your jobsdeployments/{job}.yamlto use JSON viafluentbit.io/parser: json
Package: itential.py
Itential.pyA library to (hopefully) make Itential scripting via Python a little easier.Pypi:https://pypi.org/project/itential.py/Remote Installpip install itential.pyUsagefromitentialimportItentialfromitential.modules.v2020_2importAppWorkflowEngineclient=Itential()# Contains default login and localhost url informationworkflow_engine=AppWorkflowEngine(client=client)# Pass in the auth clientresponse:"requests.Response"=workflow_engine.get_job_output(job_id="example-job-id")Local InstallCurently the repository is setup for pipenv. I'm looking into making the repository agnostic to the python environment manager (poetry, pipnev, venv).pip install pipenv
pipenv install . --dev