Saravanan666/pypi-org huggingface dataset:
Package: smart-image-renamer
A script to intelligently bulk rename images using EXIF data contained withinInstallTo install smart-image-renamer:Recommended method is via pip.pip install smart-image-renamerElse install like any other python package.python setup.py installUsageusage: smart-image-renamer.py [-h] -f FORMAT [-s SEQUENCE] [-r] [-i] [-t] [-V]
                            [-v | -q]
                            input [input ...]

Smart Image Renamer

Rename your photos in bulk using information stored in EXIF.

positional arguments:
  input          Absolute path to file or directory

optional arguments:
  -h, --help     show this help message and exit
  -f FORMAT      Format of the new file name
  -s SEQUENCE    Starting sequence number (default: 1)
  -r             Recursive mode
  -i             Include hidden files
  -t             Test mode. Don't apply changes.
  -V, --version  show program's version number and exit
  -v, --verbose
  -q, --quiet

Format string for the file name is defined by a mix of custom text and following tags enclosed in {}:
  YYYY        Year
  MM          Month
  DD          Day
  hh          Hours
  mm          Minutes
  ss          Seconds
  Seq         Sequence number
  Artist      Artist
  Make        Camera Make
  Model       Camera Model
  Folder      Parent folder of the image file

Examples:
  Format String:          {YYYY}-{MM}-{DD}-{Folder}-{Seq}
  File Name:              2014-05-09-Wedding_Shoot-001.JPEG
                          2014-05-09-Wedding_Shoot-002.JPEG

  Format String:          {YYYY}{DD}{MM}_{Model}_Beach_Shoot_{Seq}
  File Name:              20140429_PENTAX K-x_Beach_Shoot_001.JPEG
                          20140429_PENTAX K-x_Beach_Shoot_002.JPEG
Package: smart-injector
Smart-injector is an lightweight dependency injection framework for Python.
It was designed to be an easy to use tool to implement dependency injection in your application in a pythonic way.Key features are:
- Ligtweight
- pure python
- leverages type annotations
- scopes
- non invasiveProject StatusInstallationpip install smart-injectorYou can also install the in-development version with:pip install https://github.com/hlevering/python-smart-injector/archive/master.zipQuickstartBasic Usage:>>> class A:
...     pass
...
>>> class B:
...     def __init__(self, a: A):
...         self.a = a
...
>>> container = create_container(StaticContainer)
>>> b = container.get(B)
>>> isinstance(b.a, A)
TrueDocumentationDetailed documentation can be found here:https://python-smart-injector.readthedocs.io/Further usage examples can be found here:https://python-smart-injector.readthedocs.io/en/latest/usage.htmlDevelopmentTo run the all tests run:toxNote, to combine the coverage data from all the tox environments run:Windowsset PYTEST_ADDOPTS=--cov-append
toxOtherPYTEST_ADDOPTS=--cov-append toxChangelog0.0.0 (2019-11-20)First release on PyPI.
Package: smart-insights
smart-insightssmart-insights is a part ofDash Enterprise,
Plotly's end-to-end Dash application platform. This public copy of the package
is a stub published on pypi.org designed to shield Dash Enterprise users fromdependency confusion,
a remote code execution attack publicly disclosed in 2021 by Alex Birsan.If you are a Dash Enterprise user, you will only see this public package if your
app is not properly configured to find the local package repository built into
Dash Enterprise. Visit the docs for your Dash Enterprise installation for details.If you never see this public package, it's still doing its job of protecting you
from the dependency confusion attack!
Package: smartleia
[![GitHub license](https://img.shields.io/github/license/h2lab/smartleia)](https://github.com/h2lab/smartleia/blob/master/LICENSE.bsd3) [![Debian package](https://img.shields.io/debian/v/smartleia/unstable)](https://tracker.debian.org/pkg/smartleia) ![Build status](https://github.com/h2lab/smartleia/actions/workflows/main.yml/badge.svg) [![Sonarcloud Status](https://sonarcloud.io/api/project_badges/measure?project=h2lab_smartleia&metric=alert_status)](https://sonarcloud.io/dashboard?id=h2lab_smartleia)# SmartLeiaThis repository holds the source of the python package used to drive the LEIA
smartcard reader. With it, you will be able to:Connect to the LEIA boardChoose parameters for the PSS/PTS negotiationSend APDUs and receive the corresponding responsesActivate the DFU mode to download new firmwareStart a [Virtual SmartCard](https://frankmorgner.github.io/vsmartcard/)
client to use LEIA as a real smartcard reader (through pcscd)The smartleia package should be compatible withPython 3.6 and newer.## Installation### From aptIf you use debian or ubuntu, smartleia should be packaged (in the
recent versions of the distros). Simply try:`sh apt install smartleia `### From gitYou may need to use the last version of python builtin’s setuptools to install
smartleia from git:`sh python-mpip install--upgradepip setuptools wheel ``sh git clonehttps://github.com/h2lab/smartleiacd smartleia pip install--user.; `## Using smartleia with PCSCIt is possible to use smartleia in a PCSC mode, where
it communicates with the PCSC daemon so that you can
use your existing tools (such asopensc) to communicate
with the smartcard transparently. Using this mode will require
the installation ofvsmartcard-vpcdandvsmartcard-vpicc,
either from the sources in the [vsmartcard](https://github.com/frankmorgner/vsmartcard)
repository, or from your distro packages (this should be
packaged in recent debian and ubuntu distros):`sh apt installvsmartcard-vpcdvsmartcard-vpicc`Then, you can lauch PCSC daemon in a terminal:`sh pcscd-fad`And launch smartleia in PCSC relay mode:`sh python3-msmartleia `Of course, you should have your LEIA (or equivalent) board
plugged in using USB as well as a smart card present in the
connector. PCSC should spot a new ATR if everything went fine.
Package: smartlens
SmartLens Python LibraryThe SmartLens Python library provides convenient access to the SmartLens API from
applications written in the Python language. Integrate state-of-the-art AI into your application
in just five lines of code.DocumentationSee theAPI docs.InstallationTo install the package, simply run:pipinstallsmartlensRequirementsPython 3.6+UsageThe library needs to be configured with your account's API key which is
available in theSmartLens Dashboard. Setsmartlens.api_keyto its
value:importsmartlenssmartlens.api_key="YOUR-API-KEY"# tag imagetags=smartlens.runTags(image="path/to/my/image")# caption imagecaptions=smartlens.runCaptions(image="path/to/my/image")# process documentextractedItems=smartlens.runDocumentAI(document="path/to/my/document",customExtractions=[{'natural_language_query':'What is the salary?','answer_key':'employee_salary'}]# Custom extractions are optional)# process text documentextractedItems=smartlens.runTextAnalysis(text="path/to/my/text",customExtractions=[{'natural_language_query':'What is the salary?','answer_key':'employee_salary'}]# Custom extractions are optional)
Package: smartlivinglab
Smartlivinglab is a small django application designed to store data from sensors.Is heavily based on Django Rest Framework, as it exposes recolected data via an API. Also includes a write option to store data using the REST API.INSTALATION===========Install using pip-----------------pip install smartlivinglabAdd to the INSTALLED_APPS------------------------INSTALLED_APPS = (...rest_framework,rest_framework.authtoken,smartlivinglab,#if you want some simple graphics uncomment this#smartlivinglab.samples...)Run database migration----------------------$ python manage.py migrate
Package: smartlogger
Use SmartLogger in your codefromsmartloggerimportSmartLoggerlogger=SmartLogger("examplePipelineName",save_to_dir="OPTIONAL_SAVE_DIR, defaults to ./")stage=logger.Stage(unique_id,stage_name,tags=optional_list_of_tags)# code block you want to log and time, eg: model inference/ db call/ pre/post processing code# stage.debug()/ info()/ exception (logs exc info)/ error# depending on whether it succeeded or notstage.success()stage.failed()# Process to continuously upload logs to dashsmartlogger--save_dir./--server_url"http://localhost:8080"
Package: smart-match
IntroductionThe smart-match module contains functions for calculating strings/sets similarity.Conceptsimilarity:
A value in a range of [0, 1], which represents how similar the two strings are.
The larger the value, the more similar the two strings are.dissimilarity:
A value in a range of [0, 1], which represents how dissimilar the two strings are.
The larger the value, the more dissimilar the two strings are.
For a pair of strings, similarity = 1 - dissimilaritydistance:
How far the two strings are. Notice that not all the methods support distance method.scoreThe larger the score, the more similar the two strings are. Notice not all the methods have score method.We support three levels of string matching.char:
Similarity computation based on characters in the strings.term:
Similarity computation based on terms in the strings.gram:
Similarity computation based on q-grams in the strings.MethodsWe support the following methods.MethodsimilaritydissimilaritydistancescoreLevenshtein (default)✅✅✅❌Euclidean✅✅✅❌Damerau Levenshtein✅✅✅❌Block Distance✅✅✅❌Cosine✅✅❌❌Tanimoto Coefficient✅✅❌❌Dice✅✅❌❌Simon White✅✅❌❌Longest Common Substring✅✅✅✅Longest Common SubSequence✅✅✅✅Overlap Coefficient✅✅❌❌Generalized Overlap Coefficient✅✅❌❌Jaccard✅✅❌❌Generalized Jaccard✅✅❌❌Hamming✅✅✅❌Jaro✅✅❌❌Jaro Winkler✅✅❌❌Needleman Wunch✅✅❌✅Smith Waterman✅✅❌✅Smith Waterman Gotoh✅✅❌✅Monge Elkan✅✅❌❌Installationpipinstallsmart-matchUsageimportsmart_matchprint(smart_match.similarity('hello','hero'))print(smart_match.dissimilarity('hello','hero'))print(smart_match.distance('hello','hero'))Output:0.60.42CheckWikifor more details.Licensesmart-match is a free software. See the file LICENSE for the full text.Authors
Package: smartmca
SmartMCA for Caen DT5771This library allows to interface user code with the Caen DT5771 MCA Firmware.With the library it is possible to:Connect to the MCAConfigure high-level MCA/PSD processing parametersStart, stop reset 1D and 2D spectraDump waveformsCode ExamplefromsmartmcaimportSmartMCAfromsmartmcaimportConfigMCA,ConfigIOmca=SmartMCA()mca.connect("http://192.168.102.120","user","password")# or mca.connect("http://localhost", "user", "password") if used on# integrated jupiterlabmca.get_server_status()config=mca.get_mca_configuration()config.trigger_mode=ConfigMCA.TriggerMode.INTERNALconfig.le_threshold=5000config.trigger_type=ConfigMCA.TriggerType.LEADING_EDGEmca.set_mca_configuration(config)y=mca.oscilloscope_get_data(enable_trace_processing=False)plt.plot(y.channels[0].analog)plt.show()mca.histogram_start()time.sleep(5)stats=mca.get_mca_statistics()print(stats)x,counts=mca.histogram_get(rebin=16)#plot xplt.plot(x)plt.show()
Package: smartmeter-analyze
This Tool was written to analyze your personal energy consumption.The Tool currently only supports CSV files with daily consumption values, as
provided by the ‘Smart Metering’ service of ‘Wiener Netze GmbH’.Installation$ pip install smartmeter-analyzeUsagePrint a statistical summary of your energy consumption:$ smutil summary consumption-file.csvPrint the summary, using multiple files or directories:$ smutil summary ~/some_dir_with_consumption_files/ another-file.csvYou can download your energy consumption data from smartmetering.wienernetze.atFeaturesGeneration of basic consumption summaries (averages, peaks, etc.)Basic consumption predictionHandling of one or many (not necessarily disjunct) datasetsTODOMore sophisticated summariesimport/storage of dataReport generationintegration of pricing (energy only)CreditsIconThe Icon was composed by the following pictograms:Graph designed by Pham Thi Dieu Linh from the thenounproject.comSocket designed by hunotika from the thenounproject.com
Package: smartmeter-austria-energy
Smartmeter Energy AustriaLibrary for connecting to Austrian Smart Meters of Salzburg Netz, TINETZ and EVN
Retrieves the data from the M-BUS connector using a serial to USB converter.Only tested on a Kaifa MA309 and Salzburg Netz (Salzburg AG).
Some technical informations:
The device uses Wired M-Bus (RJ 12) at 2400 baud. (1 start bit, 8 data bits, 1 parity bit, even, 1 stop bit.
Communication is push only, every 5 seconds.UsageInstall this packagepip install smartmeter_austria_energyConnect to your inverter using the correct COM port and fetch the data.
Possible COM port settings:
/dev/ttyUSB0, eg. using Linux
COM5, eg using Windowsfromsmartmeter_austria_energy.supplierimport(SUPPLIER_SALZBURGNETZ_NAME)fromsmartmeter_austria_energy.smartmeterimport(Smartmeter)defmain():supplier_name=SUPPLIER_SALZBURGNETZ_NAMEkey_hex_string="-- this is your key --"port="COM5"smartmeter=Smartmeter(supplier_name,port,key_hex_string)my_obisdata=smartmeter.read()print(f"RealEnergyIn:{my_obisdata.RealEnergyIn.ValueString}")print(f"RealEnergyOut:{my_obisdata.RealEnergyOut.ValueString}")if__name__=='__main__':main()Script was tested on Linux (Ubuntu, Debian, Raspberry OS) and Windows (Windows 10, Windows 11).UsageCredits to Stefan who had done a cool work that was used in this implementation.https://github.com/tirolerstefan/kaifa
Package: smart-meter-texas
Package to asynchronously connect to and retrieve data from the unofficial Smart Meter Texas API using aiohttp.Currently only obtaining the dashboard and current meter reading are implemented. There are serval other API endpoints that are not implemented in this package.Free software: MIT licenseInstallTo install:$pipinstallsmart-meter-texasExamplePlease see the examples for an idea of how to get started using the package.CreditsThis package was created withCookiecutterand theaudreyr/cookiecutter-pypackageproject template.
Package: smartmeter-webthing
smart meter webthingA webthing connector for smart metersThis project provides a smart meterwebthing API. It provides the software to connect anIR USB sensorThe smart meter webthing package provides an http webthing endpoint that supports smart meter consumption values over http. e.g.# webthing has been started on host 192.168.0.23

curl http://192.168.0.23:7122/properties 

{
   "current_power": 389,
   "produced_power_total": 3314.7,
   "consumed_power_total": 259784.2
}To install this software, you can use thePIPpackage manager as shown belowsudo pip install smartmeter_webthingAfter installation, you can start the webthing http endpoint in your Python code or from the command line by typingsudo smartmeter --command listen --port 7122 --sport /dev/serial/by-id/usb-Silicon_Labs_CP2102_USB_to_UART_Bridge_Controller_0051-if00-port0Here the webthing API will use the local port 7122. Additionally, the device address of the IR sensor must be set. To configure the device address, seesetup device.As an alternative to thelistcommand, you can also use theregistercommand to register and start the webthing service as a systemd device.
This way, the webthing service is started automatically at boot time. Starting the server manually with thelistencommand, as shown above, is no longer necessary.sudo smartmeter --command register --port 7122 --sport /dev/serial/by-id/usb-Silicon_Labs_CP2102_USB_to_UART_Bridge_Controller_0051-if00-port0
Package: smartmin
Django SmartminSmartmin was born out of the frustration of the Django admin site not being well suited to being exposed to clients.
It aims to allow you to quickly build scaffolding which you can customize by using Django views.It is very opinionated in how it works, if you don't agree, Smartmin may not be for you:Permissions are used to gate access to each page, embrace permissions throughout and you'll love thisCRUDL operations at the object level, that is, Create, Read, Update, Delete and List, permissions and views are based
around thisURL automapping via the the CRUDL objects, this should keep things very very DRYAbout VersionsSmartmin tries to stay in lock step with the latest Django versions. With each new Django LTS release we will release
a new Smartmin major version and we will reserve major changes (possibly breaking backwards compatibility) for such
releases. This includes updating to the latest version of Twitter Bootstrap.The latest version is the 3.* series which supports the Django 3.2 LTS and 2.2 LTS.AboutThe full documentation can be found at:http://readthedocs.org/docs/smartmin/en/latest/The official source code repository is:http://www.github.com/nyaruka/smartmin/Built in Rwanda byNyaruka Ltd.
Package: smartmine
A Python library for Smartmine’s API.SetupYou can install this package by using the pip tool and installing:pip install smartmineSetting up a Smartmine AccountRegister for a free Smartmine account athttps://ai.smartmine.net/service/computer-vision/image-enhancementTry ServicesThe following services are available at Smartmine for you to try via the frontend before integrating with the API:Automated subtitling and translationImage EnhancementImage UpscalingImage SharpeningImage De-noisingImage RestorationUsing the Smartmine APIGeneral Usage:importsmartminefromsmartmineimportServiceNamesmartmine.username=input("Username: ")smartmine.password=input("Password: ")smartmine.process_image(service_name=ServiceName.image_restoration,load_path="examples/images/earth.png",save_path="results/earth_restored.png",)Advanced Usage:importosfrompathlibimportPathimportsmartminefromsmartmineimportServiceNamesmartmine.username=os.environ.get("SMARTMINE_USERNAME")smartmine.password=os.environ.get("SMARTMINE_PASSWORD")# Bulk process imagessmartmine.bulk_process_images(service_name=ServiceName.image_restoration,load_dir="examples/images/",save_dir=str(Path.home()/"Downloads"),)Running TestsFirst, make sure you have your Smartmine username and password ready, then set these as environment variables, i.e.:export SMARTMINE_USERNAME=<username>
export SMARTMINE_PASSWORD=<password>Then, usepytestto run unit tests:pytest -vv –exitfirst smartmine/
Package: smartmob-agent
DescriptionThis project is a network agent designed to remotely run applications that
follow theThe Twelve-Factor App.  All that is required of applications is
that they can be uploaded to the agent over the network and that they contain aProcfilewhich can be used to start the application’s processes.DocumentationYou can find the documentation on ReadTheDocs:latestContributingWe welcome pull requests!  Please open up an issue on theissue trackerto
discuss, fork the project and then send in a pull request :-)Feel free to add yourself to theCONTRIBUTORSfile on your first pull
request!LicenseThe source code and documentation is made available under an MIT license.  SeeLICENSEfile for details.
Package: smartmodels
SmartModelsSmart Models for FIWAREFree software: MIT licenseDocumentation:https://smartmodels.readthedocs.io.FeaturesTODOBefore Codingcreate a virtual env::python3 -m venv venv
source venv/bin/activate
make install-testing-requisitesCreditsThis package was created withCookiecutterand thecib_pypackageproject template.History0.1.0 (2024-02-07)First release on PyPI.
Package: smartmoneyconcepts
Smart Money Concepts (smc) BETAThe Smart Money Concepts Python Indicator is a sophisticated financial tool developed for traders and investors to gain insights into market sentiment, trends, and potential reversals. This indicator is built using Python, a versatile programming language known for its data analysis and visualization capabilities.InstallationpipinstallsmartmoneyconceptsUsagefromsmartmoneyconceptsimportsmcPrepare data to use with smc:smc expects properly formated ohlc DataFrame, with column names in lowercase: ["open", "high", "low", "close"] and ["volume"] for indicators that expect ohlcv input.IndicatorsFVG - Fair Value GapHighs and LowsSwing Tops and BottomsBOS and CHoCHOB - Order BlockVOB - Volumized Order BlocksLiquidityExamplesPlease take a look at smc.test.py for more detailed examples on how each indicator works.smc.fvg(ohlc)# Fair Value Gapsmc.highs_lows(ohlc)# Highs and Lowssmc.swing_tops_bottoms(ohlc,swing_length=10)# Swing Tops and Bottomssmc.bos_choch(ohlc,close_break=True,filter_liquidity=False)# Detect BOS and CHoCHsmc.ob(ohlc)# Order Blocksmc.vob(ohlc)# Volumized Order Blockssmc.liquidity(ohlc)# LiquidityContributingThis project is still in BETA so please feel free to contribute to the project. By creating your own indicators or improving the existing ones.Fork it (https://github.com/joshyattridge/smartmoneyconcepts/fork).Study how it's implemented.Create your feature branch (git checkout -b my-new-feature).Run black code formatter on the finta.py to ensure uniform code style.Commit your changes (git commit -am 'Add some feature').Push to the branch (git push origin my-new-feature).Create a new Pull Request.
Package: smartmultiprocessing
SmartMultiprocessingA drop-in replacement for Python'smultiprocessinglibrary with many extra features, including: memory management, smart task scheduling, a pause button, a GUI, and more.SmartMultiprocessingis ideal for use cases beyond typicalmultiprocessinguse, like:Running code where memory usage is different depending on input valuesBenchmarking experimental code where memory usage is not well understoodRunning code on a machine where it's important to be able to pause execution/change thread and memory use on the flyBeing able to monitor the performance of code without having to write your own monitoring library from scratchSmartMultiprocessing is in active development!This project is a spin-out from code that@emilyhuntwrote during her PhD. It's currently in alpha / active development - check back here soon for the first production-ready versions!
Package: smart-nine
Instagram Smart Ninesmart-nine is a command-line application written in Python that generates an Instagram user's smart nine photograph collage from a particular year.Example collage:InstallTo install smart-nine:$ pip install smart-nineUsageTo generate a smart nine collage:$ smart-nine <username> -u <your username> -p <your password>NOTE: To generate a smart-nine collage for a<username>which media is set to private,<your username>must be an approved follower of<username>.The resulting collage will be saved as:/smart-nine-output/<username>_<year>.jpgOptionsArgumentDescription--help, -hShow help message and exit.--login-user, -login_user, -uInstagram scraper login user.--login-pass, -login_pass, -pInstagram scraper login password.--year, -yYear to use as filter for the smart nine collage.--timezone, -tTimezone of Instagram user(s).--scrape, -sData scraping flag - set to False to work with local data.MotivationThe current software applications for generating Instagram year photo collages suffer from the following:They only display the 9 photographs that have the most likes.They require you to enter your personal email (which they use to send spam), or...They overlay unwanted graphics on top of the resulting image.LicenseMIT LicenseCopyright (c) 2020 Ulysses LizarragaPermission 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.