Saravanan666/pypi-org huggingface dataset:
Package: serobj
SerobjSerobjis a library for serializing and de-serializing program objects.Getting startedRunpip install serobjto install the latest stable version fromPyPI.Example:import json
import serobj

def print_fn(self, *args):
    print(*args)

class A:
    print_fn = print_fn

    def __init__(self):
        self.some_attr = 1, 2, 3


# -------------- dump --------------

obj = A()
data = serobj.dumps(obj)

with open("A.json", "w") as f:
    json.dump(data, f, indent=4)


# -------------- load --------------

with open("A.json", "r") as f:
    data = json.load(f)

obj = serobj.loads(data)
obj.print_fn(*obj.some_attr) # 1 2 3
Package: serotiny
serotinyserotinyis a collection of deep learning related tools and primitives, loosely meant
to be used in projects started fromlightning-hydra-templateFor more information, check ourdocumentation.AuthorsGuilherme Pires @colobasRyan Spangler @prismofeverythingRitvik Vasan @ritvikvasanCaleb Chan @calebiumTheo Knijnenburg @tknijnenNick Gomez @gomeznick86CitingIf you find serotiny useful, please cite this repository as:Serotiny Authors (2022). Serotiny: a framework of tools to structure, configure and drive deep learning projects [Computer software]. GitHub. https://github.com/AllenCellModeling/serotiny
Free software: BSD-3-Clause
Package: serp
Python API client for SERP APIFor your convenience, you can make API calls using sync or async (asyncio) interface.InstallationpipinstallserpNote that it is always recommended pinning version of your installed packages.Usage example (sync)An example of how to create an origin:fromserpimportClientif__name__=='__main__':# api_token is just str with your API tokenapi_token="abcd012345"# Now create instance of Client. There should be only one per process.client=Client(base_url="http://localhost:8080",api_token=api_token)# Issue API request to create an originclient.origins.create(name="test_name")Now that we have our origin created, we can create profile inside that origin:fromserpimportClientdefcreate_profiles_example(client:Client):origin_id=1# you can inspect response from `client.origins.create`withopen("image.png","rb")asf:response=client.profiles.create(image=f,origin_id=origin_id)print("Profiles Create Response:\n",response.json(),flush=True)if__name__=='__main__':# api_token is just str with your API tokenapi_token="abcd012345"# Now create instance of Client. There should be only one per process.client=Client(base_url="http://localhost:8080",api_token=api_token)# Issue API request to create a profilecreate_profiles_example(client)Now that we have our origin & profile created, we can search for profile:fromserpimportClientdefsearch_profiles_example(client:Client):withopen("image.png","rb")asf:response=client.profiles.search(image=f,identify_asm=True)print("Profiles Search Response:\n",response.json(),flush=True)if__name__=='__main__':# api_token is just str with your API tokenapi_token="abcd012345"# Now create instance of Client. There should be only one per process.client=Client(base_url="http://localhost:8080",api_token=api_token)# Issue API request to search profilessearch_profiles_example(client)For more examples and usage, please refer to thedocs.Development setupTo install all the development requirements:pipinstall--upgradepip
pipinstallpoetry
poetryinstall--no-rootTo run linters & test suite:./scripts/test.shHow to releaseUpdate version in:CHANGELOG.md__init__.pypyproject.tomlLock deps to update version in poetry:poetry lockGet API Token from account settings inPyPIpoetry config pypi-token.pypi YOUR_API_TOKENpoetry buildpoetry publishRelease History0.1.4Changed name to SERPMinor fixes0.1.1Fixed types of custom Enum classes and in corresponding methods0.1.0Initial version of packageLicenseDistributed under the MIT license. SeeLICENSEfor more information.ContributingCreate your feature branch (git checkout -b feature/fooBar)Commit your changes (git commit -am 'Add some fooBar')Push to the branch (git push origin feature/fooBar)Create a new Pull Request
Package: serp-bot
SERP BotThis is a utility that has gives the basic use of scraping web engines. This is simple in the way it works, however, just using some common sense would allow you to make some rather advanced uses of this.Caution : SERP bots are a legal gray zone.This can be installed through pip.pipinstallserp-botAlternatively, you could download this repository and install it with pip.pip3install.UsingThis has 3 components that can be made use of. SERPBot, GenericSearchEngine and RequestDispatcher.Sample usage :fromserp_botimportSERPBot,RequestDispatcherbot=SERPBot()dispatcher=RequestDispatcher()engine=bot.get_random_search_engine()print(engine)engine.build_base_query('hello world')print(engine.get_current_url())dispatcher.get(engine.get_current_url()[0])print(dispatcher.last_response.text)withopen('sample.html','w+')ashtml_file:html_file.write(dispatcher.last_response.text)Alternatively, using the RequestDispatcher can help avoid some Web Scraping detection units.fromserp_botimportRequestDispatcherrequest_dispatcher=RequestDispatcher()response=request_dispatcher.get('https://google.com/search?q=crapper+zapper')print(response.content)
Package: serpentarium
serpentariumA Python framework for running plugins with conflicting dependenciesDescriptionComing soon!Installationpip install serpentariumCaveatsThis package is highly experimentalimport serpentariummust be the first thing that your code imports so that
it can save the state of the interpreter's import system before any other
imports modify it.MultiprocessingPlugin only works with the "spawn" method (for now). On Linux,
you'll need to use a multiprocessing Context object with the "spawn" method
to generate any Locks, Events, or other synchronization primitives that will
be passed to a plugin.SECURITY: This project loads and executes code from files. Do not load or run
plugins from untrusted sources.DevelopmentPre-commit hookspre-commit install
Package: serpentime
SerpentimeSerpentime is a simple time tracking software to create Chronodex graph, a
kind of pie chart where each slice represents a time dedicated to an activity.Source code repository and issue tracker:https://github.com/xamcost/serpentimeRequirementsPython:$\qquad$Serpentime is developed with Python 3.8.2PyQt5:$\qquad$https://pypi.org/project/PyQt5/InstallationThe easiest way to install Serpentime is viapip:pip install serpentimeThen, you can launch the app by simply running:python -m serpentime.app
Package: serpentscribe
SerpentScribeserpentscribeis a simple, yet powerful Python logging library designed to make function call logging effortless. No longer do you have to instantiate logging multiple times within a function or class.  This module provides a simple decorator to automatically log the details of function calls, including arguments and return values to stdout and optionally to a JSON file specified.FeaturesEasy to use: Simply decorate your functions to start logging.Logsfunction name,argumentspassed, returnvalues, andtimestamp.Customizable log file path when exporting to a file.InstallationInstallSerpentScribeusingpipenv:pipenvinstallserpentscribeor if you haven't graduated toPIPENVyet, (you probably should) you can install usingPIP:pipinstallserpentscribeUsageTo use SerpentScribe, import the log_output decorator and apply it to any function.  All inputs and outputs are logged to stdout and if specified, to a JSON file:fromserpentscribe.loggerimportlog_output# Specify logger level (required) and file path (optional)@log_output(logger_level="DEBUG",file_path="/path/to/log/file")defmy_function(arg1,arg2):# Function logic herereturn"Result"Logging LevelA logging level is a required argument when setting the decorator. The following are supported:LEVELDescriptionDEBUGDetailed information, typically only of interest to a developer trying to diagnose a problem.INFOConfirmation that things are working as expected.WARNINGAn indication that something unexpected happened, or that a problem might occur in the near future (e.g. ‘disk space low’). The software is still working as expected.ERRORDue to a more serious problem, the software has not been able to perform some function.CRITICALA serious error, indicating that the program itself may be unable to continue running.Logging to a FileSerpentScribe will always output to stdout.  If a file is specified, then logging will be sent tostdoutas well as the specified file.
The log file will have the logs written in JSON format, which is both human-readable and easy to process programmatically. If a path for the log file is not specified, the logs will instead be written tostdout.Running TestsTo run tests, navigate to the root directory of the project and execute:python-munittestdiscover-stestsContributionContributions to SerpentScribe are welcome! Please read the contributing guidelinesCONTRIBUTIONto get started.LicenseSerpentScribe is licensed under the MIT License. See theLICENSEfile for more details.ContactFor any queries or suggestions, feel free to contact the maintainer using Github
Package: serpentTools
A suite of parsers designed to make interacting withSERPENT[1]output files simple and flawless.TheSERPENTMonte Carlo code
is developed by VTT Technical Research Centre of Finland, Ltd.
More information, including distribution and licensing ofSERPENTcan be
found athttp://montecarlo.vtt.fiInstallationserpentToolscan be installed withpipusing:$ pip install serpentToolsFor more detailed instructions, including operating-system specific
instructions and building from source, seeInstallation Guide.IssuesIf you have issues installing the project, find a bug, or want to add a feature,
theGitHub issue pageis the best place to do that.SupportThe development ofserpentToolsis supported by the following organizations:USNC-TechReferencesThe Annals of Nuclear Energy article should be cited for all work
usingSERPENT. If you are using this project, please considering
citing withAndrew Johnson, Dan Kotlyar, Stefano Terlizzi, and Gavin Ridley,
“serpentTools: A Python Package for Expediting Analysis with
Serpent,”Nuc. Sci. Eng, 2020, 194, 1016-1024Also, let us know if you publish work using this package! We try and
keep an up-to-date list of works using serpentTools[2], and would be
happy to include more.[1]Leppanen, J. et al. (2015) “The Serpent Monte Carlo code: Status,
development and applications in 2013.” Ann. Nucl. Energy,82 (2015) 142-150[2]https://serpent-tools.readthedocs.io/en/latest/publications.html
Package: serplint
A linter for theSerpentlanguage.screenshotInstallation$pipinstall--upgradeserplintUsage$serplintfilename.seCurrent testsundefined variablesreassigned argumentsunused argumentsunused assignmentPlanned testsarray index out of boundsdata and event shadowingmagic numbersIntegrationsSublime Text 3syntaxandlinterneovim +
neovmakeTODOVisual Studio Code
Package: serprog
SerProgA serial and secure programming tool for microcontroller.Reference projectSAME54BOOTBootloader for Microchip SAME54 series MCU (ARM Cortex-M4F)NuM487BOOTBootloader for Nuvoton M480 series MCU (ARM Cortex-M4F)AuxMCUbootBootloader for auxiliary MCU (ATmega16U4). The main function is to convert USB-UART protocol.DownloadYou can install this package from PyPI using pip. Simply run the following command:pipinstallserprogUsageusage:serprogprog[-h][-dDEVICE]-pPORT[-fFLASH_FILE][-efEXT_FLASH_FILE][-eEEPROM_FILE][-flashboot]options:-h,--helpshowthishelpmessageandexit-dDEVICE,--deciceDEVICEThenameornumberofthedevicetypetobeprogrammed.Canseeavailabledevicetypebysubcommandprint-device-list.-pPORT,--portPORTTheserialportwhichprogramburnthedevice.-fFLASH_FILE,--flashFLASH_FILESetbinaryfilewhichprogramtoflash.-efEXT_FLASH_FILE,--extflashEXT_FLASH_FILESetbinaryfilewhichprogramtoexternelflash.-eEEPROM_FILE,--eepromEEPROM_FILESetbinaryfilewhichprogramtoeeprom.-flashboot,--extflash_bootProgramfromexternelflashtointernelflash.[Example]: program the specified image file (.hex) into the MCU's internal flash.serprogprog-pCOM1-fimage.hex[Example]: program the specified image file (.hex) into the development board's NOR flash.serprogprog-pCOM1-efimage.hexBoot schemeBootloader ProtocolCommunication handshakeCommunication commandFlowchartBootloader packet formatBootloader data formatSecure Boot
Package: serpy
serpyis a super simple object serialization framework built for speed.serpyserializes complex datatypes (Django Models, custom classes, …) to
simple native types (dicts, lists, strings, …). The native types can easily
be converted to JSON or any other format needed.The goal ofserpyis to be able to do thissimply,reliably, andquickly. Since serializers are class based, they can be combined, extended
and customized with very little code duplication. Compared to other popular
Python serialization frameworks likemarshmalloworDjango Rest Framework Serializersserpyis at
least anorder of magnitudefaster.SourceSource at:https://github.com/clarkduvall/serpyIf you want a feature, send a pull request!DocumentationFull documentation at:http://serpy.readthedocs.org/en/latest/Installation$pipinstallserpyExamplesSimple ExampleimportserpyclassFoo(object):"""The object to be serialized."""y='hello'z=9.5def__init__(self,x):self.x=xclassFooSerializer(serpy.Serializer):"""The serializer schema definition."""# Use a Field subclass like IntField if you need more validation.x=serpy.IntField()y=serpy.Field()z=serpy.Field()f=Foo(1)FooSerializer(f).data# {'x': 1, 'y': 'hello', 'z': 9.5}fs=[Foo(i)foriinrange(100)]FooSerializer(fs,many=True).data# [{'x': 0, 'y': 'hello', 'z': 9.5}, {'x': 1, 'y': 'hello', 'z': 9.5}, ...]Nested ExampleimportserpyclassNestee(object):"""An object nested inside another object."""n='hi'classFoo(object):x=1nested=Nestee()classNesteeSerializer(serpy.Serializer):n=serpy.Field()classFooSerializer(serpy.Serializer):x=serpy.Field()# Use another serializer as a field.nested=NesteeSerializer()f=Foo()FooSerializer(f).data# {'x': 1, 'nested': {'n': 'hi'}}Complex ExampleimportserpyclassFoo(object):y=1z=2super_long_thing=10defx(self):return5classFooSerializer(serpy.Serializer):w=serpy.Field(attr='super_long_thing')x=serpy.Field(call=True)plus=serpy.MethodField()defget_plus(self,obj):returnobj.y+obj.zf=Foo()FooSerializer(f).data# {'w': 10, 'x': 5, 'plus': 3}Inheritance ExampleimportserpyclassFoo(object):a=1b=2classASerializer(serpy.Serializer):a=serpy.Field()classABSerializer(ASerializer):"""ABSerializer inherits the 'a' field from ASerializer.

    This also works with multiple inheritance and mixins.
    """b=serpy.Field()f=Foo()ASerializer(f).data# {'a': 1}ABSerializer(f).data# {'a': 1, 'b': 2}Licenseserpy is free software distributed under the terms of the MIT license. See theLICENSEfile.
Package: serpyco
What is Serpyco ?Serpyco is a serialization library forPython 3.6+ dataclassesthat works just by defining your dataclasses:importdataclassesimporttypingimportserpyco@dataclasses.dataclassclassExample(object):name:strnum:inttags:typing.List[str]serializer=serpyco.Serializer(Example)result=serializer.dump(Example(name="foo",num=2,tags=["hello","world"]))print(result){'name':'foo','num':2,'tags':['hello','world']}Serpyco works by analysing the dataclass fields and can recognize many types :List,Set,Tuple,Optional,Union… You can also embed other dataclasses in a definition.The main use-case for Serpyco is to serialize objects for an API, but it can be helpful whenever you need to transform objects to/from builtin Python types.FeaturesSerialization and unserialization of dataclassesValidation of input/output dataVery fastExtensible through custom encodersInstallingSerpyco is best installed via pip:pipinstallserpycoIt has only 3 (4 with python 3.6 dataclasses backport) dependencies:rapid-json: used for data validation and fast JSON dump/loadpython-dateutil: used for serializing datetime objectstyping_inspect: used to inspect types as needed to create serializersDocumentationDocumentationAPI ReferenceContributingSerpyco is written usingPythonandCythonfor parts needing speed.Issue trackerSource code
Package: serpyco-d7
What is Serpyco ?Serpyco is a serialization library forPython 3.6+ dataclassesthat works just by defining your dataclasses:importdataclassesimporttypingimportserpyco@dataclasses.dataclassclassExample(object):name:strnum:inttags:typing.List[str]serializer=serpyco.Serializer(Example)result=serializer.dump(Example(name="foo",num=2,tags=["hello","world"]))print(result){'name':'foo','num':2,'tags':['hello','world']}Serpyco works by analysing the dataclass fields and can recognize many types :List,Set,Tuple,Optional,Union… You can also embed other dataclasses in a definition.The main use-case for Serpyco is to serialize objects for an API, but it can be helpful whenever you need to transform objects to/from builtin Python types.FeaturesSerialization and unserialization of dataclassesValidation of input/output dataVery fastExtensible through custom encodersInstallingSerpyco is best installed via pip:pipinstallserpycoIt has only 3 (4 with python 3.6 dataclasses backport) dependencies:rapid-json: used for data validation and fast JSON dump/loadpython-dateutil: used for serializing datetime objectstyping_inspect: used to inspect types as needed to create serializersDocumentationDocumentationAPI ReferenceContributingSerpyco is written usingPythonandCythonfor parts needing speed.Issue trackerSource code
Package: serpycow
What is Serpyco ?Serpyco is a serialization library forPython 3.6+ dataclassesthat works just by defining your dataclasses:importdataclassesimporttypingimportserpyco@dataclasses.dataclassclassExample(object):name:strnum:inttags:typing.List[str]serializer=serpyco.Serializer(Example)result=serializer.dump(Example(name="foo",num=2,tags=["hello","world"]))print(result){'name':'foo','num':2,'tags':['hello','world']}Serpyco works by analysing the dataclass fields and can recognize many types :List,Set,Tuple,Optional,Union… You can also embed other dataclasses in a definition.The main use-case for Serpyco is to serialize objects for an API, but it can be helpful whenever you need to transform objects to/from builtin Python types.FeaturesSerialization and unserialization of dataclassesValidation of input/output dataVery fastExtensible through custom encodersInstallingSerpyco is best installed via pip:pipinstallserpycoIt has only 3 (4 with python 3.6 dataclasses backport) dependencies:rapid-json: used for data validation and fast JSON dump/loadpython-dateutil: used for serializing datetime objectstyping_inspect: used to inspect types as needed to create serializersDocumentationDocumentationAPI ReferenceContributingSerpyco is written usingPythonandCythonfor parts needing speed.Issue trackerSource code
Package: serpy-ctp
serpyis a super simple object serialization framework built for speed.serpyserializes complex datatypes (Django Models, custom classes, …) to
simple native types (dicts, lists, strings, …). The native types can easily
be converted to JSON or any other format needed.The goal ofserpyis to be able to do thissimply,reliably, andquickly. Since serializers are class based, they can be combined, extended
and customized with very little code duplication. Compared to other popular
Python serialization frameworks likemarshmalloworDjango Rest Framework Serializersserpyis at
least anorder of magnitudefaster.This is a forked version that include de possibility to remove None field from the output.
It is recommanded that you used the upstream version available athttps://github.com/clarkduvall/serpySourceSource at:https://github.com/clarkduvall/serpyIf you want a feature, send a pull request!DocumentationFull documentation at:http://serpy.readthedocs.org/en/latest/Installation$pipinstallserpyExamplesSimple ExampleimportserpyclassFoo(object):"""The object to be serialized."""y='hello'z=9.5def__init__(self,x):self.x=xclassFooSerializer(serpy.Serializer):"""The serializer schema definition."""# Use a Field subclass like IntField if you need more validation.x=serpy.IntField()y=serpy.Field()z=serpy.Field()f=Foo(1)FooSerializer(f).data# {'x': 1, 'y': 'hello', 'z': 9.5}fs=[Foo(i)foriinrange(100)]FooSerializer(fs,many=True).data# [{'x': 0, 'y': 'hello', 'z': 9.5}, {'x': 1, 'y': 'hello', 'z': 9.5}, ...]Nested ExampleimportserpyclassNestee(object):"""An object nested inside another object."""n='hi'classFoo(object):x=1nested=Nestee()classNesteeSerializer(serpy.Serializer):n=serpy.Field()classFooSerializer(serpy.Serializer):x=serpy.Field()# Use another serializer as a field.nested=NesteeSerializer()f=Foo()FooSerializer(f).data# {'x': 1, 'nested': {'n': 'hi'}}Complex ExampleimportserpyclassFoo(object):y=1z=2super_long_thing=10defx(self):return5classFooSerializer(serpy.Serializer):w=serpy.Field(attr='super_long_thing')x=serpy.Field(call=True)plus=serpy.MethodField()defget_plus(self,obj):returnobj.y+obj.zf=Foo()FooSerializer(f).data# {'w': 10, 'x': 5, 'plus': 3}Inheritance ExampleimportserpyclassFoo(object):a=1b=2classASerializer(serpy.Serializer):a=serpy.Field()classABSerializer(ASerializer):"""ABSerializer inherits the 'a' field from ASerializer.

    This also works with multiple inheritance and mixins.
    """b=serpy.Field()f=Foo()ASerializer(f).data# {'a': 1}ABSerializer(f).data# {'a': 1, 'b': 2}Licenseserpy is free software distributed under the terms of the MIT license. See theLICENSEfile.
Package: serrano
# Serrano[![Build Status](https://travis-ci.org/chop-dbhi/serrano.svg?branch=master)](https://travis-ci.org/chop-dbhi/serrano) [![Coverage Status](https://img.shields.io/coveralls/chop-dbhi/serrano.svg)](https://coveralls.io/r/chop-dbhi/serrano?branch=master)Serrano is a [hypermedia](https://en.wikipedia.org/wiki/Hypermedia) implementation for [Avocado](http://avocado.harvest.io) that adheres to the constraints of [REST](https://en.wikipedia.org/wiki/Representational_state_transfer).## Documentationhttp://serrano.harvest.io## DevelopmentSee the [contributing](https://github.com/chop-dbhi/serrano/blob/master/CONTRIBUTING.md) guide.