Saravanan666/pypi-org huggingface dataset:
Package: screener
ScreenerCheck e-book files for security and privacy issues.MotivationE-books are great, but the common file formats have security and privacy issues. Most use web browser technologies like HTML, CSS, and JavaScript. Therefore, e-books are vulnerable to security and privacy issues that already exist on the web.Screener aims to check e-book files for these issues so that you can read with peace of mind!FeaturesCheck e-book files for JavaScript tags.Check e-book files for images with external sources to prevent tracking.Supports.epub,.mobi, and.azw3files.Get startedPrerequisitesScreener requiresPython.InstallingScreener is available onPyPI. To install, run:pipinstallscreenerDevelopment installationTo install Screener for development, ensure you havePoetryclone the repository and run:poetryinstallUsageTo check a file, try:screenerpath/to/file.epubFor help:screener--helpContributingPull requests are welcome and appreciated. For major changes, please open an issue first to discuss what you would like to change. Please make sure to update tests as appropriate.If you have found a bug or have a feature request, please open an issue.VersioningThis project usesSemVerfor versioning.AuthorsScreener was created by Tom Kuson (@tjkuson).LicenceScreener is released under theLGPL version 3.
Package: screen-html
Python Screen HtmlThis is a Python script that uses Async Playwright to render HTML and convert it into an image.Features:Support cssSupport just html and html filesUsing jinja2Screenshot can be taken with omit_background and full_page optionsChange user-agent supportDocumentation:Examples can be found in the /examples directory.Regular Example:importscreen_htmlasshimportasyncioasyncdefmain():awaitsh.render_html('<html><body><h1>{{ h1 }}</h1></body></html>',{'h1':'Hello world!'})awaitsh.screenshot('./screen.png',omit_background=False)asyncio.run(main())Copyright:This program is licensed under the MIT.Copyright Notice:MIT License

Copyright (c) 2023 Xpos587

Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
Package: screeninfo
screeninfoFetch location and size of physical screens.Supported environmentsMS WindowsMS Windows: CygwinGNU/Linux: X11 (through Xinerama)GNU/Linux: DRM (experimental)OSX: (through AppKit)I don't plan on testing OSX or other environments myself. For this reason,
I strongly encourage pull requests.Installationpip install screeninfoUsagefromscreeninfoimportget_monitorsforminget_monitors():print(str(m))Output:Monitor(x=3840,y=0,width=3840,height=2160,width_mm=1420,height_mm=800,name='HDMI-0',is_primary=False)Monitor(x=0,y=0,width=3840,height=2160,width_mm=708,height_mm=399,name='DP-0',is_primary=True)Forcing environmentIn some cases (emulating X server on Cygwin etc.) you might want to specify the
driver directly. You can do so by passing extra parameter toget_monitors()like this:fromscreeninfoimportget_monitors,Enumeratorforminget_monitors(Enumerator.OSX):print(str(m))Available drivers:windows,cygwin,x11,osx.Contributinggitclonehttps://github.com/rr-/screeninfo.git# clone this repocdscreeninfo
poetryinstall# to install the local venvpoetryrunpre-commitinstall# to setup pre-commit hookspoetryshell# to enter the venvThis project usespoetryfor packaging,
install instructions atpoetry#installation
Package: screenly-ose
Screenly OSE API ClientLibrary to enable control of Screenly OSE digital signage viaREST API.Free software: MIT licenseSample Usageimportasyncioimportaiohttpimportscreenly_oseasyncdefrun():asyncwithaiohttp.ClientSession()assession:screenly=screenly_ose.Screenly(session,'192.168.1.112')asset=awaitscreenly.get_current_asset()print(asset)asyncio.run(run())APIConstructorScreenly(websession, hostname, port=80, encryption=False, timeout=None)Creates a new connection to a Screenly OSE instance running on the given hostname and port.MethodsAll instance methods returnFalsein the event of a request error.get_current_asset()Returns a dict containing the following info about the asset currently being displayed:idThe asset IDnameThe asset nametypeThe asset typenext_asset()Requests Screenly to display the next asset in the sequence.previous_asset()Requests Screenly to display the previous asset in the sequence.switch_asset(asset_id)Requests Screenly to display the asset with the given ID string.CreditsThis package was created withCookiecutterand theaudreyr/cookiecutter-pypackageproject template.
Package: screen-master
screen-masterA cli tool for interact with GNU screen more easily.Description:A cli tool for interact with GNU screen more easily.What can screen-master do?It can make you build project inGNU screenmore easily.It can make you enter into the screen or kill it faster.Config Template[section]
window title = command (allow multiple lines)How To Use:Set up your config:[hello]window01=python3window02=echo \"HELLO world\"window03=echo \"HELLO WORLD\";echo \"hello world\";window04=echo \"hello world\"echo \"hey python\"CLI command:Build screen ->sbuild -s sectionsbuild -s helloEnter into the screen ->srun -s screen namesrun -s helloKill the screen ->skill -s screen nameskill -s worldyou can also kill all screen if you don't choose any screen by screen indexBuy me a coffee, if you like it!
Package: screenmonkey
Screen MonkeyThis package allows users to record and execute sequences of on-screen actions by interacting with Sequence objects.Currently, only mouse actions are supported -- development of keyboard support is underway.Currently, only saving/loading through excel files is supported -- csv and other filetypes is under developemnt.Thanks to Pravin Nath for developing the pynput library, which this packed is based off. Details here:https://github.com/pravinnath/pynputInstallationExamplesTo record and save a Sequence of actions:fromscreenmonkeyimportSequencemySeq=Sequence()# initializes your Sequence objectmySeq.record()# prompts user to do actions that they wish to recordmySeq.save_excel('testSeq.xlsx')# saves Sequence as Excel file for repeated useTo run a saved Sequence:fromscreenmonkeyimportSequencemySeq=Sequence()# initializes your Sequence objectmySeq.load_excel('testSeq.xlsx')# loads a saved Sequence of actionsmySeq.run()# prompts user to prepare screen, then executes actionsContactScreen Monkey is developed by Bryce Merrill, please contact at:brycelmerrill@gmail.com
Package: screen-ocr
Screen OCRThescreen-ocrpackage makes it easy to perform OCR on portions of the screen.InstallationChoose one of the following backends and follow the steps. WinRT is recommended for Windows and Tesseract for all other platforms.WinRTWinRT is a Windows-only backend that is very fast and reasonably accurate. To install screen-ocr with WinRT support, runpip install screen-ocr[winrt]TesseractTesseract is a cross-platform backend that is much slower and slightly less accurate than WinRT. To install screen-ocr with Tesseract support:Install Tesseract binaries. For Windows, seehttps://github.com/UB-Mannheim/tesseract/wiki.pip install screen-ocr[tesseract]EasyOCREasyOCR is a very accurate but slow backend and only runs on Python 64-bit, and hence is considered experimental. To install screen-ocr with WinRT support, runpip install screen-ocr[easyocr]UsageYou can do a simple test by runningpython -m screen_ocrto OCR the current screen contents. See__main__.pyfor the code.If using Tesseract with a custom installation directory on Windows, settesseract_data_pathandtesseract_commandpaths appropriately when
constructing aReaderinstance.See alsogaze-ocrfor more a more involved usage example.
Package: screenot
ScreeNOT: Optimal Singular Value Thresholding in Correlated NoiseScreeNOT is a code library for hard thresholding of singular values. The procedure adaptively estimates the best singular value threshold under unknown noise characteristics. The threshold chosen by ScreeNOT is optimal (asymptotically, in the sense of minimum Frobenius error) under the the so-called "Spiked model" of a low-rank matrix observed in additive noise. In contrast to previous works, the noise isnotassumed to be i.i.d. or white; it can have an essentially andunknowncorrelation structure, across either rows, columns or both.
ScreeNOT is proposed to practitioners as a mathematically solid alternative to Cattell's ever-popular but vague Scree Plot heuristic from 1966.Please refer to the project's homepage:https://github.com/eladromanov/ScreeNOTUsageThe main API for this package is the functionadaptiveHardThresholding(Y, k, strategy='i')It receives as input a matrixY(in Python: anumpyarray); a non-negative integerk, an upper bound (potentially loose) on the low-rank signal to-be-recovered; (optional) a stringstrategy, which defines an estimation strategy for the noise bulk - valid options are'i'(imputation; this is the default, and should be best for most practical uses),'0'(transport to zero) or'w'(winsorization) - see paper for details.The function returns three values:Xest: a matrix with same dimensions asY; an estimator for the low-rank signal (the result of performing thresholding on the singular values ofY).Topt: the hard threshold which was used; computed adaptively from the singular values ofY.r: the number of "relevant"/"strong" components of the signal: r=rank(Xest).
Package: screenpen
Multiplatform screen annotation software that allows drawing directly on the screen.DescriptionScreen annotation software which allows drawing directly on the screen.
It is an open source and multiplatform
(all systems that support Python)
alternative to tools such as Epic Pen.
Supported shapes:line,rectangle,chart (using matplotlib).The behavior of the program depends on the Window System you use:if the system supports "live transparency then a transparent background is used (you can see a video playing in the background),if not then the screenshot is taken, and the user draws on the captured image (you see a static image of the screen),sometimes your WM may be detected as not supporting "live transparency". In that case try running with-tparameter to force it._Demo (video)https://user-images.githubusercontent.com/19404835/130215780-705e4eb9-330b-4a91-bd1f-b9ec3843556e.mp4Note: The app is created ad-hoc only for my use case. It may contain bugs...UsageInstallation and executionTu run the program you need to have Python installed and execute following:pipinstallscreenpen
screenpen# or python -m screenpenNOTE: Your WM may be detected as not supporting "live transparency". In that case try running with-tparameter:screenpen-tControlsLeft mouse button - drawing.Right mouse button - quit.Keyboard shortcuts:Ctrl+Z- undo,Ctrl+Y- redo,holdShift- change mouse cursor icon to arrrow.ConfigurationThere are a few configuration options that can be set using config file:icon_size- size of the icons (default: 50)hidden_menus- to hide menus on start (default: False)The config should look like below:[screenpen]; Possible values for areas: topToolBarArea, bottomToolBarArea, leftToolBarArea, rightToolBarAreapenbar_area=topToolBarAreaboardbar_area=topToolBarAreaactionbar_area=leftToolBarAreahidden_menus=Falseicon_size=50(more options will be added in the future...)TODOBetter Matplotlib charts support.Better wayland support.Extended configuration.Compatilibity notesScreenpen (from 0.2 version) is compatible with PyQt5 and PyQt6, nevertheless the PyQt5 is currently in the requirements and recommended.
It is possible to run it using PyQt6 by running:pip install matplotlib>=3.2 numpy>=1.8 PyQt6
pip install screenpen --no-depsWayland supportScreenpen works in some Wayland compositors, but it is not perfect.
There are issues with windows positioning and transparency.
In case the window opens on wrong monitor (which I noticed on Sway WM) you can move it usingWin+Shift+Arrows(orAlt+Shift+Arrows) shortcuts to a desired monitor.
I have no plans to fix it in near future, but I will accept PRs.
Package: screenplain
About ScreenplainYou're a hacker. The command line is your home. You know tools like grep, sed
and Git inside out. You have formed a symbiotic relationship with your text
editor. Those tools are powerful in the right hands. But you're also a
screenwriter. Screenwriting is much like programming. It's about structure and
form, and -- obviously -- about reading, writing and modifying huge amounts of
text. You don't want to use software that lacks the power of your hacking
tools just because you're writing a screenplay instead of a shell script.Enter Screenplain.Screenplain allows you to write a screenplay as a plain text file using
a format calledFountain. Text files
are simple and supported by all text manipulation software. It's not just for
hackers, too. The simplicity of plain text allows you to easily view and edit
them on devices such as tablets and phones. No need for specific screenwriting
software.The magic that Screenplain performs is to take your plain text file and
convert it to a good looking screenplay in an industry standard format.
Send that file off to your producer, agent, director or screenwriting
competition. The supported output formats are FDX  HTML, and PDF.Screenplain can be used as a command-line application or a library.
AnOnline version of Screenplainis also
available.Note that Screenplain is under development and is missing features and
the master branch may not always work. I'm currently working on supporting
the wholeFountainspecification. (Fountain
was previously known as "Screenplay Markdown" or "SPMD.")Installingpip install screenplainTo enable PDF output, install with the PDF extra (installs ReportLab):pip install 'screenplain[PDF]'CreditsScreenplain was coded byMartin Vilcans.The CSS code that formats Screenplain's HTML output as something that
looks as much as a printed screenplay as is possible in HTML was
created byJonathan Poritsky.TheFountainfile format is the result of a
collaboration betweenStu MaschwitzandJohn August.LicenseScreenplain is released under theMIT license.DevelopingSet up virtual environment:python3 -m venv .venv
. .venv/bin/activate
pip install -r requirements.txt
pip install -e .After this, thescreenplaincommand will use the working copy of your code.To run unit tests and style checks, run:bin/test
Package: screenpoint
ScreenPointFinds the (x,y) coordinates of the centroid of an image (eg: a mobile phone camera image) pointing at another image (eg: a computer screen) usingOpenCV SIFT.InstallationpipinstallscreenpointUsageimportscreenpointimportcv2# Load input images.screen=cv2.imread('screen.png',0)view=cv2.imread('view.jpg',0)# Project view centroid to screen space.# x and y are the coordinate of the `view` centroid in `screen` space.x,y=screenpoint.project(view,screen)Seeexample.pyfor more information.
Package: screenpy
ScreenPyTITLE CARD:
                                  "ScreenPy"
TITLE DISAPPEARS.
                                                                      FADE IN:
INT. DOCUMENTATION - NIGHT

Illuminated by the computer's glow, AUDIENCE sits reading the documentation
for a Python library they haven't seen before. AUDIENCE is visibly startled
as a dulcet voice begins to speak.

                              NARRATOR (V.O.)
            ScreenPy is a library that provides the base for an
            automated test suite using Screenplay Pattern.

                              AUDIENCE
            Wha- who are you? Where are you? And... what is
            Screenplay Pattern?!

                              NARRATOR (V.O.)
            It's a composition-based architecture pattern,
            encouraging automated test writers to write more
            maintainable test suites. It allows test writers to
            use Gherkin-style language in Python to create
            descriptive UI tests.

                              AUDIENCE
                              (reluctantly)
            Ignoring how you avoided answering my first questions,
            how do I get started?

                              NARRATOR (V.O.)
            I thought you'd never ask...

                                                                      FADE OUTInstallationpip install screenpyDocumentationPlease check out theRead The Docs documentationfor the latest information about this module!ContributingYou want to contribute? Great! Here are the things you should do before submitting your PR:Fork the repo and git clone your fork.devinstall the project package:pip install -e .[dev]Optional (poetry users):poetry install --extras devRunpre-commit installonce.Runtoxto perform tests frequently.Create pull-request from your branch.That's it! :)
Package: screenpy-adapter-allure
ScreenPy Adapter: AllureTITLE CARD:
                         "ScreenPy Adapter: Allure"
TITLE DISAPPEARS.
                                                                      FADE IN:
INT. DOCUMENTATION - UNKNOWN TIME

A recording room door opens and AUDIENCE peeks inside. AUDIENCE quietly steps
over cords and around chairs, approaching the switchboard. NARRATOR quietly
resumes their guidance.

                              NARRATOR (V.O.)
            Ah, this is one of the Adapters for my microphone. This
            one sends them to an Allure report.

                              AUDIENCE
                              (hushed)
            You mean you have a literal microphone, and that's how
            you're talking to me? I thought I had been stingy to
            some tester and you were the first of three spirits.

                              NARRATOR (V.O.)
            Not a literal microphone, but it's a helpful metaphor.

                              AUDIENCE
                              (hushed)
            That's not as helpful as you think it is, when your
            voice is in my head.

A beat, as AUDIENCE looks appraisingly at the equipment.

                              AUDIENCE (CONT'D)
                              (hushed)
            This looks complicated. I'm leaving now.

                              NARRATOR (V.O.)
            Let's turn left outside the door...

                                                                      FADE OUTInstallationpip install screenpy_adapter_allureorpip install screenpy[allure]DocumentationPlease check out theRead The Docs documentationfor the latest information about this module!You can also read theScreenPy Docsfor more information about ScreenPy in general.ContributingYou want to contribute? Great! Here are the things you should do before submitting your PR:Installpre-commitrunpre-commit installonce.runtoxto perform tests frequently.That's it! :)
Package: screenpy-appium
ScreenPy AppiumTITLE CARD:
                               "ScreenPy Appium"
TITLE DISAPPEARS.
                                                                      FADE IN:
INT. DOCUMENTATION - MIDNIGHT

Camera fades in on a white, slightly curved wall. AUDIENCE enters from a
hidden door and stumbles, sliding down the smooth surface - this room is
spherical. The door closes and disappears again.

                              AUDIENCE
                              (surprised)
            Whoa! What is this place?

In the center of the sphere floats a many-armed robot, interacting with
dozens of nearby gadgets. They whir, whizz, and flash lights as the robot
twitches knobs and toggles levers.

                              NARRATOR (V.O.)
            This is the Appium extension module. Appium allows you to
            automate many different kinds of devices. This module
            allows your Actors to interact with it.

AUDIENCE observes the robot warily, yet a fascinated expression creeps
onto their face. A beat, then AUDIENCE shakes their head to snap out of
it. AUDIENCE looks around, confused.

                              AUDIENCE
            Uh, so how do we get out of here?

As if summoned by the question, a round aperture opens in the floor
beneath the robot, and an elevator appears. AUDIENCE cautiously steps
onto it and suddenly descends out of frame.

                                                                      FADE OUTInstallationpip install screenpy_appiumorpip install screenpy[appium]DocumentationPlease check out theRead The Docs documentationfor the latest information about this module!ContributingYou want to contribute? Great! Here are the things you should do before submitting your PR:Installpre-commitrunpre-commit installonce.runtoxto perform tests frequently.That's it! :)
Package: screenpy-playwright
ScreenPy PlaywrightTITLE CARD:
                               "ScreenPy Playwright"
TITLE DISAPPEARS.
                                                                      FADE IN:
INT. DOCUMENTATION - GLOAMING

Scene settles on an UNKNOWN MAN, feverishly writing with an overly fancy
quill at a writing desk. Several crumpled papers are around him, but there
is a sizeable stack intact, scrawled with text. The writing desk is butted
against a large window, with a beautiful view of the dwindling sunset.
Bookshelves crammed with books flank the window; it is clear the books are
frequently taken down and put back in different spots. AUDIENCE gently opens
a nearby door.

                              AUDIENCE
                              (whispering)
            Oh! Excuse me, i didn't mean to intrude.

The UNKNOWN MAN does not look up, as if he did not hear AUDIENCE. He continues
writing.

                              NARRATOR (V.O.)
            This young man is the Playwright extension for
            ScreenPy. He is relatively new here, but he has
            quite a large reputation backing him.

                              AUDIENCE
            Can he hear me? And wait, he's a real man?

                              NARRATOR (V.O.)
            He is singularly focused. He is real, in a sense.

                              AUDIENCE
            Does he ever, y'know... eat? Sleep?

                              NARRATOR (V.O.)
            No.

                              AUDIENCE
            All right, you've got a strange definition of "real."

AUDIENCE takes one last look at PLAYWRIGHT before leaving, softly closing
the door behind them.

                                                                      FADE OUTInstallationpip install screenpy_playwrightorpip install screenpy[playwright]DocumentationPlease check out theRead The Docs documentationfor the latest information about this module!You can also read theScreenPy Docsfor more information about ScreenPy in general.ContributingYou want to contribute? Great! Here are the things you should do before submitting your PR:Fork the repo and git clone your fork.devinstall the project package:pip install -e .[dev]Optional (poetry users):poetry install --extras devRunpre-commit installonce.Runtoxto perform tests frequently.Create pull-request from your branch.That's it! :)